watir 6.13.0 → 6.14.0

data/spec/watirspec/wait_spec.rb

@@ -1,31 +1,32 @@
-require "watirspec_helper"
+require 'watirspec_helper'
 
 describe Watir::Element do
   before do
-    browser.goto WatirSpec.url_for("wait.html")
+    browser.goto WatirSpec.url_for('wait.html')
   end
 
   # TODO: This is deprecated; remove in future version
   not_compliant_on :relaxed_locate do
-    describe "#when_present" do
-      it "invokes subsequent method calls when the element becomes present" do
+    describe '#when_present' do
+      it 'invokes subsequent method calls when the element becomes present' do
         browser.a(id: 'show_bar').click
 
         bar = browser.div(id: 'bar')
         bar.when_present(2).click
-        expect(bar.text).to eq "changed"
+        expect(bar.text).to eq 'changed'
       end
 
-      it "times out when given a block" do
+      it 'times out when given a block' do
         expect { browser.div(id: 'bar').when_present(1) {} }.to raise_error(Watir::Wait::TimeoutError)
       end
 
-      it "times out when not given a block" do
-        message = /^timed out after 1 seconds, waiting for (\{:id=>"bar", :tag_name=>"div"\}|\{:tag_name=>"div", :id=>"bar"\}) to become present$/
-        expect { browser.div(id: 'bar').when_present(1).click }.to raise_error(Watir::Wait::TimeoutError, message)
+      it 'times out when not given a block' do
+        locator = '(\{:id=>"bar", :tag_name=>"div"\}|\{:tag_name=>"div", :id=>"bar"\})'
+        msg = /^timed out after 1 seconds, waiting for #{locator} to become present$/
+        expect { browser.div(id: 'bar').when_present(1).click }.to raise_error(Watir::Wait::TimeoutError, msg)
       end
 
-      it "responds to Element methods" do
+      it 'responds to Element methods' do
         decorator = browser.div.when_present
 
         expect(decorator).to respond_to(:exist?)
@@ -33,17 +34,17 @@ describe Watir::Element do
         expect(decorator).to respond_to(:click)
       end
 
-      it "delegates present? to element" do
+      it 'delegates present? to element' do
         Object.class_eval do
           def present?
             false
           end
         end
-        element = browser.a(id: "show_bar").when_present(1)
+        element = browser.a(id: 'show_bar').when_present(1)
         expect(element).to be_present
       end
 
-      it "processes before calling present?" do
+      it 'processes before calling present?' do
         browser.a(id: 'show_bar').click
         expect(browser.div(id: 'bar').when_present.present?).to be true
       end
@@ -51,7 +52,7 @@ describe Watir::Element do
   end
 
   compliant_on :relaxed_locate do
-    it "clicking automatically waits until the element appears" do
+    it 'clicking automatically waits until the element appears' do
       browser.a(id: 'show_bar').click
       expect { browser.div(id: 'bar').click }.to_not raise_exception
       expect(browser.div(id: 'bar').text).to eq 'changed'
@@ -64,12 +65,11 @@ describe Watir::Element do
     it "raises exception if the element doesn't become enabled" do
       expect { browser.button(id: 'btn').click }.to raise_object_disabled_exception
     end
-
   end
 
   not_compliant_on :relaxed_locate do
-    describe "#wait_until &:enabled?" do
-      it "invokes subsequent method calls when the element becomes enabled" do
+    describe '#wait_until &:enabled?' do
+      it 'invokes subsequent method calls when the element becomes enabled' do
         browser.a(id: 'enable_btn').click
 
         btn = browser.button(id: 'btn')
@@ -78,7 +78,7 @@ describe Watir::Element do
         expect(btn.disabled?).to be true
       end
 
-      it "times out" do
+      it 'times out' do
         error = Watir::Wait::TimeoutError
         inspected = '#<Watir::Button: located: true; {:id=>"btn", :tag_name=>"button"}>'
         message = "timed out after 1 seconds, waiting for true condition on #{inspected}"
@@ -86,7 +86,7 @@ describe Watir::Element do
         expect { element.wait_until(timeout: 1, &:enabled?).click }.to raise_error(error, message)
       end
 
-      it "responds to Element methods" do
+      it 'responds to Element methods' do
         element = browser.button.wait_until { true }
 
         expect(element).to respond_to(:exist?)
@@ -94,7 +94,7 @@ describe Watir::Element do
         expect(element).to respond_to(:click)
       end
 
-      it "can be chained with #wait_until &:present?" do
+      it 'can be chained with #wait_until &:present?' do
         browser.a(id: 'show_and_enable_btn').click
         browser.button(id: 'btn2').wait_until(&:present?).wait_until(&:enabled?).click
 
@@ -104,13 +104,13 @@ describe Watir::Element do
     end
   end
 
-  describe "#wait_until_present" do
-    it "waits until the element appears" do
+  describe '#wait_until_present' do
+    it 'waits until the element appears' do
       browser.a(id: 'show_bar').click
       expect { browser.div(id: 'bar').wait_until_present(timeout: 5) }.to_not raise_exception
     end
 
-    it "waits until the element re-appears" do
+    it 'waits until the element re-appears' do
       browser.link(id: 'readd_bar').click
       expect { browser.div(id: 'bar').wait_until_present }.to_not raise_exception
     end
@@ -118,24 +118,21 @@ describe Watir::Element do
     it "times out if the element doesn't appear" do
       inspected = '#<Watir::Div: located: true; {:id=>"bar", :tag_name=>"div"}>'
       error = Watir::Wait::TimeoutError
-      message = "timed out after 1 seconds, waiting for true condition on #{inspected}"
+      message = "timed out after 1 seconds, waiting for element #{inspected} to become present"
 
       expect { browser.div(id: 'bar').wait_until_present(timeout: 1) }.to raise_error(error, message)
     end
 
-    it "uses provided interval" do
+    it 'uses provided interval' do
       element = browser.div(id: 'bar')
       expect(element).to receive(:present?).twice
 
-      begin
-        element.wait_until_present(timeout: 0.4, interval: 0.2)
-      rescue Watir::Wait::TimeoutError
-      end
+      expect { element.wait_until_present(timeout: 0.4, interval: 0.2) }.to raise_timeout_exception
     end
   end
 
-  describe "#wait_while_present" do
-    it "waits until the element disappears" do
+  describe '#wait_while_present' do
+    it 'waits until the element disappears' do
       browser.a(id: 'hide_foo').click
       expect { browser.div(id: 'foo').wait_while_present(timeout: 2) }.to_not raise_exception
     end
@@ -143,21 +140,18 @@ describe Watir::Element do
     it "times out if the element doesn't disappear" do
       error = Watir::Wait::TimeoutError
       inspected = '#<Watir::Div: located: true; {:id=>"foo", :tag_name=>"div"}>'
-      message = "timed out after 1 seconds, waiting for false condition on #{inspected}"
+      message = "timed out after 1 seconds, waiting for element #{inspected} not to be present"
       expect { browser.div(id: 'foo').wait_while_present(timeout: 1) }.to raise_error(error, message)
     end
 
-    it "uses provided interval" do
+    it 'uses provided interval' do
       element = browser.div(id: 'foo')
       expect(element).to receive(:present?).twice
 
-      begin
-        element.wait_until_present(timeout: 0.4, interval: 0.2)
-      rescue Watir::Wait::TimeoutError
-      end
+      expect { element.wait_until_present(timeout: 0.4, interval: 0.2) }.to raise_timeout_exception
     end
 
-    it "does not error when element goes stale" do
+    it 'does not error when element goes stale' do
       element = browser.div(id: 'foo').tap(&:exists?)
 
       allow(element).to receive(:stale?).and_return(false, true)
@@ -166,161 +160,161 @@ describe Watir::Element do
       expect { element.wait_while_present(timeout: 1) }.to_not raise_exception
     end
 
-    it "waits until the selector no longer matches" do
+    it 'waits until the selector no longer matches' do
       element = browser.link(name: 'add_select').wait_until(&:exists?)
       browser.link(id: 'change_select').click
       expect { element.wait_while_present }.not_to raise_error
     end
   end
 
-  describe "#wait_until" do
-    it "returns element for additional actions" do
+  describe '#wait_until' do
+    it 'returns element for additional actions' do
       element = browser.div(id: 'foo')
       expect(element.wait_until(&:exist?)).to eq element
     end
 
-    it "accepts self in block" do
+    it 'accepts self in block' do
       element = browser.div(id: 'bar')
       browser.a(id: 'show_bar').click
       expect { element.wait_until { |el| el.text == 'bar' } }.to_not raise_exception
     end
 
-    it "accepts any values in block" do
+    it 'accepts any values in block' do
       element = browser.div(id: 'bar')
       expect { element.wait_until { true } }.to_not raise_exception
     end
 
-    it "accepts just a timeout parameter" do
+    it 'accepts just a timeout parameter' do
       element = browser.div(id: 'bar')
       expect { element.wait_until(timeout: 0) { true } }.to_not raise_exception
     end
 
-    it "accepts just a message parameter" do
+    it 'accepts just a message parameter' do
       element = browser.div(id: 'bar')
       expect { element.wait_until(message: 'no') { true } }.to_not raise_exception
     end
 
-    it "accepts just an interval parameter" do
+    it 'accepts just an interval parameter' do
       element = browser.div(id: 'bar')
       expect { element.wait_until(interval: 0.1) { true } }.to_not raise_exception
     end
 
-    context "accepts keywords instead of block" do
+    context 'accepts keywords instead of block' do
       before { browser.refresh }
 
-      it "accepts text keyword" do
+      it 'accepts text keyword' do
         element = browser.div(id: 'bar')
         browser.a(id: 'show_bar').click
         expect { element.wait_until(text: 'bar') }.to_not raise_exception
       end
 
-      it "accepts regular expression value" do
+      it 'accepts regular expression value' do
         element = browser.div(id: 'bar')
         browser.a(id: 'show_bar').click
         expect { element.wait_until(style: /block/) }.to_not raise_exception
       end
 
-      it "accepts multiple keywords" do
+      it 'accepts multiple keywords' do
         element = browser.div(id: 'bar')
         browser.a(id: 'show_bar').click
         expect { element.wait_until(text: 'bar', style: /block/) }.to_not raise_exception
       end
 
-      it "accepts custom keyword" do
+      it 'accepts custom keyword' do
         element = browser.div(id: 'bar')
         browser.a(id: 'show_bar').click
         expect { element.wait_until(custom: 'bar') }.to_not raise_exception
       end
 
-      it "times out when single keyword not met" do
+      it 'times out when single keyword not met' do
         element = browser.div(id: 'bar')
         expect { element.wait_until(id: 'foo') }.to raise_timeout_exception
       end
 
-      it "times out when one of multiple keywords not met" do
+      it 'times out when one of multiple keywords not met' do
         element = browser.div(id: 'bar')
         expect { element.wait_until(id: 'bar', text: 'foo') }.to raise_timeout_exception
       end
 
-      it "times out when a custom keywords not met" do
+      it 'times out when a custom keywords not met' do
         element = browser.div(id: 'bar')
         expect { element.wait_until(custom: 'foo') }.to raise_timeout_exception
       end
     end
   end
 
-  describe "#wait_while" do
-    it "returns element for additional actions" do
+  describe '#wait_while' do
+    it 'returns element for additional actions' do
       element = browser.div(id: 'foo')
       browser.a(id: 'hide_foo').click
       expect(element.wait_while(&:present?)).to eq element
     end
 
     not_compliant_on :safari do
-      it "accepts self in block" do
+      it 'accepts self in block' do
         element = browser.div(id: 'foo')
         browser.a(id: 'hide_foo').click
         expect { element.wait_while { |el| el.text == 'foo' } }.to_not raise_exception
       end
     end
 
-    it "accepts any values in block" do
+    it 'accepts any values in block' do
       element = browser.div(id: 'foo')
       expect { element.wait_while { false } }.to_not raise_exception
     end
 
-    it "accepts just a timeout parameter" do
+    it 'accepts just a timeout parameter' do
       element = browser.div(id: 'foo')
       expect { element.wait_while(timeout: 0) { false } }.to_not raise_exception
     end
 
-    it "accepts just a message parameter" do
+    it 'accepts just a message parameter' do
       element = browser.div(id: 'foo')
       expect { element.wait_while(message: 'no') { false } }.to_not raise_exception
     end
 
-    it "accepts just an interval parameter" do
+    it 'accepts just an interval parameter' do
       element = browser.div(id: 'foo')
       expect { element.wait_while(interval: 0.1) { false } }.to_not raise_exception
     end
 
-    context "accepts keywords instead of block" do
-      it "accepts text keyword" do
+    context 'accepts keywords instead of block' do
+      it 'accepts text keyword' do
         element = browser.div(id: 'foo')
         browser.a(id: 'hide_foo').click
         expect { element.wait_while(text: 'foo') }.to_not raise_exception
       end
 
-      it "accepts regular expression value" do
+      it 'accepts regular expression value' do
         element = browser.div(id: 'foo')
         browser.a(id: 'hide_foo').click
         expect { element.wait_while(style: /block/) }.to_not raise_exception
       end
 
-      it "accepts multiple keywords" do
+      it 'accepts multiple keywords' do
         element = browser.div(id: 'foo')
         browser.a(id: 'hide_foo').click
         expect { element.wait_while(text: 'foo', style: /block/) }.to_not raise_exception
       end
 
-      it "accepts custom attributes" do
+      it 'accepts custom attributes' do
         element = browser.div(id: 'foo')
         browser.a(id: 'hide_foo').click
         expect { element.wait_while(custom: '') }.to_not raise_exception
       end
 
-      it "times out when single keyword not met" do
+      it 'times out when single keyword not met' do
         element = browser.div(id: 'foo')
         expect { element.wait_while(id: 'foo') }.to raise_timeout_exception
       end
 
-      it "times out when one of multiple keywords not met" do
+      it 'times out when one of multiple keywords not met' do
         element = browser.div(id: 'foo')
         browser.a(id: 'hide_foo').click
         expect { element.wait_while(id: 'foo', style: /block/) }.to raise_timeout_exception
       end
 
-      it "times out when one of custom keywords not met" do
+      it 'times out when one of custom keywords not met' do
         element = browser.div(id: 'foo')
         expect { element.wait_while(custom: '') }.to raise_timeout_exception
       end
@@ -329,41 +323,26 @@ describe Watir::Element do
 end
 
 describe Watir do
-  describe "#default_timeout" do
+  describe '#default_timeout' do
     before do
-      Watir.default_timeout = 1
-
-      browser.goto WatirSpec.url_for("wait.html")
-    end
-
-    after do
-      # Reset the default timeout
-      Watir.default_timeout = 30
+      browser.goto WatirSpec.url_for('wait.html')
     end
 
-    context "when no timeout is specified" do
-      it "is used by Wait#until" do
-        expect {
-          Watir::Wait.until { false }
-        }.to raise_error(Watir::Wait::TimeoutError)
+    context 'when no timeout is specified' do
+      it 'is used by Wait#until' do
+        expect { Watir::Wait.until { false } }.to wait_and_raise_timeout_exception(timeout: 1)
       end
 
-      it "is used by Wait#while" do
-        expect {
-          Watir::Wait.while { true }
-        }.to raise_error(Watir::Wait::TimeoutError)
+      it 'is used by Wait#while' do
+        expect { Watir::Wait.while { true } }.to wait_and_raise_timeout_exception(timeout: 1)
       end
 
-      it "is used by Element#wait_until_present" do
-        expect {
-          browser.div(id: 'bar').wait_until_present
-        }.to raise_error(Watir::Wait::TimeoutError)
+      it 'is used by Element#wait_until_present' do
+        expect { browser.div(id: 'bar').wait_until_present }.to wait_and_raise_timeout_exception(timeout: 1)
       end
 
-      it "is used by Element#wait_while_present" do
-        expect {
-          browser.div(id: 'foo').wait_while_present
-        }.to raise_error(Watir::Wait::TimeoutError)
+      it 'is used by Element#wait_while_present' do
+        expect { browser.div(id: 'foo').wait_while_present }.to wait_and_raise_timeout_exception(timeout: 1)
       end
     end
   end

data/spec/watirspec/window_switching_spec.rb

@@ -1,10 +1,10 @@
-require "watirspec_helper"
+require 'watirspec_helper'
 
-describe "Browser" do
+describe 'Browser' do
   before do
-    url = WatirSpec.url_for("window_switching.html")
+    url = WatirSpec.url_for('window_switching.html')
     browser.goto url
-    browser.a(id: "open").click
+    browser.a(id: 'open').click
     Watir::Wait.until { browser.windows.size == 2 }
   end
 
@@ -13,93 +13,94 @@ describe "Browser" do
     browser.windows.reject(&:current?).each(&:close)
   end
 
-  describe "#windows" do
-    it "returns an array of window handles" do
+  describe '#windows' do
+    it 'returns an array of window handles' do
       wins = browser.windows
       expect(wins).to_not be_empty
       wins.each { |win| expect(win).to be_kind_of(Watir::Window) }
     end
 
-    it "only returns windows matching the given selector" do
-      expect(browser.windows(title: "closeable window").size).to eq 1
+    it 'only returns windows matching the given selector' do
+      browser.wait_until { |b| b.window(title: 'closeable window').exists? }
+      expect(browser.windows(title: 'closeable window').size).to eq 1
     end
 
-    it "raises ArgumentError if the selector is invalid" do
-      expect { browser.windows(name: "foo") }.to raise_error(ArgumentError)
+    it 'raises ArgumentError if the selector is invalid' do
+      expect { browser.windows(name: 'foo') }.to raise_error(ArgumentError)
     end
 
-    it "returns an empty array if no window matches the selector" do
-      expect(browser.windows(title: "noop")).to eq []
+    it 'returns an empty array if no window matches the selector' do
+      expect(browser.windows(title: 'noop')).to eq []
     end
   end
 
-  describe "#window" do
-    it "finds window by :url" do
+  describe '#window' do
+    it 'finds window by :url' do
       w = browser.window(url: /closeable\.html/).use
       expect(w).to be_kind_of(Watir::Window)
     end
 
-    it "finds window by :title" do
-      w = browser.window(title: "closeable window").use
+    it 'finds window by :title' do
+      w = browser.window(title: 'closeable window').use
       expect(w).to be_kind_of(Watir::Window)
     end
 
-    it "finds window by :index" do
+    it 'finds window by :index' do
       w = browser.window(index: 1).use
       expect(w).to be_kind_of(Watir::Window)
     end
 
-    it "should not find incorrect handle" do
+    it 'should not find incorrect handle' do
       expect(browser.window(handle: 'bar')).to_not be_present
     end
 
-    it "returns the current window if no argument is given" do
+    it 'returns the current window if no argument is given' do
       expect(browser.window.url).to match(/window_switching\.html/)
     end
 
-    it "stores the reference to a window when no argument is given" do
+    it 'stores the reference to a window when no argument is given' do
       original_window = browser.window
       browser.window(index: 1).use
       expect(original_window.url).to match(/window_switching\.html/)
     end
 
-    bug "https://bugzilla.mozilla.org/show_bug.cgi?id=1223277", :firefox do
+    bug 'https://bugzilla.mozilla.org/show_bug.cgi?id=1223277', :firefox do
       not_compliant_on :headless do
-        it "it executes the given block in the window" do
-          browser.window(title: "closeable window") do
-            link = browser.a(id: "close")
+        it 'it executes the given block in the window' do
+          browser.window(title: 'closeable window') {
+            link = browser.a(id: 'close')
             expect(link).to exist
             link.click
-          end.wait_while(&:present?)
+          }.wait_while(&:present?)
 
           expect(browser.windows.size).to eq 1
         end
       end
     end
 
-    it "raises ArgumentError if the selector is invalid" do
-      expect { browser.window(name: "foo") }.to raise_error(ArgumentError)
+    it 'raises ArgumentError if the selector is invalid' do
+      expect { browser.window(name: 'foo') }.to raise_error(ArgumentError)
     end
 
-    it "raises a NoMatchingWindowFoundException error if no window matches the selector" do
-      expect { browser.window(title: "noop").use }.to raise_no_matching_window_exception
+    it 'raises a NoMatchingWindowFoundException error if no window matches the selector' do
+      expect { browser.window(title: 'noop').use }.to raise_no_matching_window_exception
     end
 
     it "raises a NoMatchingWindowFoundException error if there's no window at the given index" do
       expect { browser.window(index: 100).use }.to raise_no_matching_window_exception
     end
 
-    it "raises NoMatchingWindowFoundException error when attempting to use a window with an incorrect handle" do
+    it 'raises NoMatchingWindowFoundException error when attempting to use a window with an incorrect handle' do
       expect { browser.window(handle: 'bar').use }.to raise_no_matching_window_exception
     end
   end
 end
 
-describe "Window" do
+describe 'Window' do
   context 'multiple windows' do
     before do
-      browser.goto WatirSpec.url_for("window_switching.html")
-      browser.a(id: "open").click
+      browser.goto WatirSpec.url_for('window_switching.html')
+      browser.a(id: 'open').click
       Watir::Wait.until { browser.windows.size == 2 }
     end
 
@@ -108,78 +109,78 @@ describe "Window" do
       browser.windows.reject(&:current?).each(&:close)
     end
 
-    not_compliant_on :safari, %i(firefox linux) do
-      describe "#close" do
-        it "closes a window" do
-          browser.a(id: "open").click
+    not_compliant_on :safari, %i[firefox linux] do
+      describe '#close' do
+        it 'closes a window' do
+          browser.a(id: 'open').click
           Watir::Wait.until { browser.windows.size == 3 }
 
-          browser.window(title: "closeable window").close
+          browser.window(title: 'closeable window').close
           expect(browser.windows.size).to eq 2
         end
       end
 
-      it "closes the current window" do
-        browser.a(id: "open").click
+      it 'closes the current window' do
+        browser.a(id: 'open').click
         Watir::Wait.until { browser.windows.size == 3 }
 
-        window = browser.window(title: "closeable window").use
+        window = browser.window(title: 'closeable window').use
         window.close
         expect(browser.windows.size).to eq 2
       end
     end
 
-    describe "#use" do
-      it "switches to the window" do
-        browser.window(title: "closeable window").use
-        expect(browser.title).to eq "closeable window"
+    describe '#use' do
+      it 'switches to the window' do
+        browser.window(title: 'closeable window').use
+        expect(browser.title).to eq 'closeable window'
       end
     end
 
-    describe "#current?" do
-      it "returns true if it is the current window" do
+    describe '#current?' do
+      it 'returns true if it is the current window' do
         expect(browser.window(title: browser.title)).to be_current
       end
 
-      it "returns false if it is not the current window" do
-        expect(browser.window(title: "closeable window")).to_not be_current
+      it 'returns false if it is not the current window' do
+        expect(browser.window(title: 'closeable window')).to_not be_current
       end
     end
 
-    describe "#title" do
-      it "returns the title of the window" do
+    describe '#title' do
+      it 'returns the title of the window' do
         titles = browser.windows.map(&:title)
         expect(titles.size).to eq 2
 
-        expect(titles.sort).to eq ["window switching", "closeable window"].sort
+        expect(titles.sort).to eq ['window switching', 'closeable window'].sort
       end
 
-      it "does not change the current window" do
-        expect(browser.title).to eq "window switching"
-        expect(browser.windows.find { |w| w.title == "closeable window" }).to_not be_nil
-        expect(browser.title).to eq "window switching"
+      it 'does not change the current window' do
+        expect(browser.title).to eq 'window switching'
+        expect(browser.windows.find { |w| w.title == 'closeable window' }).to_not be_nil
+        expect(browser.title).to eq 'window switching'
       end
     end
 
-    describe "#url" do
-      it "returns the url of the window" do
-        expect(browser.windows.select { |w| w.url =~ (/window_switching\.html/) }.size).to eq 1
-        expect(browser.windows.select { |w| w.url =~ (/closeable\.html$/) }.size).to eq 1
+    describe '#url' do
+      it 'returns the url of the window' do
+        expect(browser.windows.select { |w| w.url =~ /window_switching\.html/ }.size).to eq 1
+        expect(browser.windows.select { |w| w.url =~ /closeable\.html$/ }.size).to eq 1
       end
 
-      it "does not change the current window" do
+      it 'does not change the current window' do
         expect(browser.url).to match(/window_switching\.html/)
-        expect(browser.windows.find { |w| w.url =~ (/closeable\.html/) }).to_not be_nil
+        expect(browser.windows.find { |w| w.url =~ /closeable\.html/ }).to_not be_nil
         expect(browser.url).to match(/window_switching/)
       end
     end
 
-    describe "#eql?" do
-      it "knows when two windows are equal" do
+    describe '#eql?' do
+      it 'knows when two windows are equal' do
         expect(browser.window).to eq browser.window(index: 0)
       end
 
-      it "knows when two windows are not equal" do
+      it 'knows when two windows are not equal' do
         win1 = browser.window(index: 0)
         win2 = browser.window(index: 1)
 
@@ -188,20 +189,20 @@ describe "Window" do
     end
 
     not_compliant_on :relaxed_locate do
-      describe "#wait_until &:present?" do
-        it "times out waiting for a non-present window" do
+      describe '#wait_until &:present?' do
+        it 'times out waiting for a non-present window' do
           expect {
-            browser.window(title: "noop").wait_until(timeout: 0.5, &:present?)
+            browser.window(title: 'noop').wait_until(timeout: 0.5, &:present?)
           }.to raise_error(Watir::Wait::TimeoutError)
         end
       end
     end
   end
 
-  context "with a closed window" do
+  context 'with a closed window' do
     before do
-      browser.goto WatirSpec.url_for("window_switching.html")
-      browser.a(id: "open").click
+      browser.goto WatirSpec.url_for('window_switching.html')
+      browser.a(id: 'open').click
       Watir::Wait.until { browser.windows.size == 2 }
     end
 
@@ -210,20 +211,20 @@ describe "Window" do
       browser.windows.reject(&:current?).each(&:close)
     end
 
-    bug "https://bugzilla.mozilla.org/show_bug.cgi?id=1223277", :firefox do
+    bug 'https://bugzilla.mozilla.org/show_bug.cgi?id=1223277', :firefox do
       not_compliant_on :headless do
-        describe "#exists?" do
-          it "returns false if previously referenced window is closed" do
-            window = browser.window(title: "closeable window")
+        describe '#exists?' do
+          it 'returns false if previously referenced window is closed' do
+            window = browser.window(title: 'closeable window')
             window.use
-            browser.a(id: "close").click
+            browser.a(id: 'close').click
             Watir::Wait.until { browser.windows.size == 1 }
             expect(window).to_not be_present
           end
 
-          it "returns false if closed window is referenced" do
-            browser.window(title: "closeable window").use
-            browser.a(id: "close").click
+          it 'returns false if closed window is referenced' do
+            browser.window(title: 'closeable window').use
+            browser.a(id: 'close').click
             Watir::Wait.until { browser.windows.size == 1 }
             expect(browser.window).to_not be_present
           end
@@ -231,18 +232,18 @@ describe "Window" do
       end
     end
 
-    describe "#current?" do
-      it "returns false if the referenced window is closed" do
+    describe '#current?' do
+      it 'returns false if the referenced window is closed' do
         original_window = browser.window
-        browser.window(title: "closeable window").use
+        browser.window(title: 'closeable window').use
         original_window.close
         expect(original_window).to_not be_current
       end
     end
 
     not_compliant_on :safari, :headless do
-      describe "#eql?" do
-        it "should return false when checking equivalence to a closed window" do
+      describe '#eql?' do
+        it 'should return false when checking equivalence to a closed window' do
           original_window = browser.window
           other_window = browser.window(index: 1)
           other_window.use
@@ -253,18 +254,18 @@ describe "Window" do
     end
 
     not_compliant_on :headless do
-      describe "#use" do
-        it "raises NoMatchingWindowFoundException error when attempting to use a referenced window that is closed" do
+      describe '#use' do
+        it 'raises NoMatchingWindowFoundException error when attempting to use a referenced window that is closed' do
           original_window = browser.window
           browser.window(index: 1).use
           original_window.close
           expect { original_window.use }.to raise_no_matching_window_exception
         end
 
-        bug "https://bugzilla.mozilla.org/show_bug.cgi?id=1223277", :firefox do
-          it "raises NoMatchingWindowFoundException error when attempting to use the current window if it is closed" do
-            browser.window(title: "closeable window").use
-            browser.a(id: "close").click
+        bug 'https://bugzilla.mozilla.org/show_bug.cgi?id=1223277', :firefox do
+          it 'raises NoMatchingWindowFoundException error when attempting to use the current window if it is closed' do
+            browser.window(title: 'closeable window').use
+            browser.a(id: 'close').click
             Watir::Wait.until { browser.windows.size == 1 }
             expect { browser.window.use }.to raise_no_matching_window_exception
           end
@@ -273,15 +274,15 @@ describe "Window" do
     end
   end
 
-  bug "https://bugzilla.mozilla.org/show_bug.cgi?id=1223277", :firefox do
+  bug 'https://bugzilla.mozilla.org/show_bug.cgi?id=1223277', :firefox do
     not_compliant_on :headless do
-      context "with current window closed" do
+      context 'with current window closed' do
         before do
-          browser.goto WatirSpec.url_for("window_switching.html")
-          browser.a(id: "open").click
+          browser.goto WatirSpec.url_for('window_switching.html')
+          browser.a(id: 'open').click
           Watir::Wait.until { browser.windows.size == 2 }
-          browser.window(title: "closeable window").use
-          browser.a(id: "close").click
+          browser.window(title: 'closeable window').use
+          browser.a(id: 'close').click
           Watir::Wait.until { browser.windows.size == 1 }
         end
 
@@ -290,65 +291,63 @@ describe "Window" do
           browser.windows[1..-1].each(&:close)
         end
 
-        describe "#present?" do
-          it "should find window by index" do
+        describe '#present?' do
+          it 'should find window by index' do
             expect(browser.window(index: 0)).to be_present
           end
 
-          it "should find window by url" do
+          it 'should find window by url' do
             expect(browser.window(url: /window_switching\.html/)).to be_present
           end
 
-          it "should find window by title" do
-            expect(browser.window(title: "window switching")).to be_present
+          it 'should find window by title' do
+            expect(browser.window(title: 'window switching')).to be_present
           end
         end
 
-        describe "#use" do
-
-          context "switching windows without blocks" do
-            it "by index" do
+        describe '#use' do
+          context 'switching windows without blocks' do
+            it 'by index' do
               browser.window(index: 0).use
-              expect(browser.title).to be == "window switching"
+              expect(browser.title).to be == 'window switching'
             end
 
-            it "by url" do
+            it 'by url' do
               browser.window(url: /window_switching\.html/).use
-              expect(browser.title).to be == "window switching"
+              expect(browser.title).to be == 'window switching'
             end
 
-            it "by title" do
-              browser.window(title: "window switching").use
+            it 'by title' do
+              browser.window(title: 'window switching').use
               expect(browser.url).to match(/window_switching\.html/)
             end
           end
 
-          context "Switching windows with blocks" do
-            it "by index" do
-              browser.window(index: 0).use { expect(browser.title).to be == "window switching" }
+          context 'Switching windows with blocks' do
+            it 'by index' do
+              browser.window(index: 0).use { expect(browser.title).to be == 'window switching' }
             end
 
-            it "by url" do
-              browser.window(url: /window_switching\.html/).use { expect(browser.title).to be == "window switching" }
+            it 'by url' do
+              browser.window(url: /window_switching\.html/).use { expect(browser.title).to be == 'window switching' }
             end
 
-            it "by title" do
-              browser.window(title: "window switching").use { expect(browser.url).to match(/window_switching\.html/) }
+            it 'by title' do
+              browser.window(title: 'window switching').use { expect(browser.url).to match(/window_switching\.html/) }
             end
           end
-
         end
       end
     end
   end
 
-  context "manipulating size and position" do
+  context 'manipulating size and position' do
     before do
-      browser.goto WatirSpec.url_for("window_switching.html")
+      browser.goto WatirSpec.url_for('window_switching.html')
     end
 
     not_compliant_on :headless do
-      it "should get the size of the current window" do
+      it 'should get the size of the current window' do
         size = browser.window.size
 
         expect(size.width).to be > 0
@@ -356,7 +355,7 @@ describe "Window" do
       end
     end
 
-    it "should get the position of the current window" do
+    it 'should get the position of the current window' do
       pos = browser.window.position
 
       expect(pos.x).to be >= 0
@@ -364,11 +363,11 @@ describe "Window" do
     end
 
     not_compliant_on :headless do
-      it "should resize the window" do
+      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
@@ -378,13 +377,13 @@ describe "Window" do
       end
     end
 
-    not_compliant_on :headless, %i(remote firefox) do
-      it "should move the window" do
+    not_compliant_on :headless, %i[remote firefox] do
+      it 'should move the window' do
         initial_pos = browser.window.position
 
         browser.window.move_to(
-            initial_pos.x + 2,
-            initial_pos.y + 2
+          initial_pos.x + 2,
+          initial_pos.y + 2
         )
 
         new_pos = browser.window.position
@@ -395,11 +394,11 @@ describe "Window" do
 
     not_compliant_on :headless do
       compliant_on :window_manager do
-        it "should maximize the window" do
+        it 'should maximize the window' do
           initial_size = browser.window.size
           browser.window.resize_to(
-              initial_size.width,
-              initial_size.height - 20
+            initial_size.width,
+            initial_size.height - 20
           )
 
           browser.window.maximize