watir 7.2.0 → 7.3.0

data/spec/watirspec/cookies_spec.rb

@@ -2,166 +2,195 @@
 
 require 'watirspec_helper'
 
-describe 'Browser#cookies' do
-  after { browser.cookies.clear }
+module Watir
+  describe Cookies do
+    after { browser.cookies.clear }
 
-  it 'gets an empty list of cookies' do
-    browser.goto WatirSpec.url_for 'index.html'
-    expect(browser.cookies.to_a).to eq []
-  end
-
-  it 'gets any cookies set' do
-    browser.goto set_cookie_url
-
-    verify_cookies_count 1
-
-    cookie = browser.cookies.to_a.first
-    expect(cookie[:name]).to eq 'monster'
-    expect(cookie[:value]).to eq '1'
-  end
+    it 'gets an empty list of cookies' do
+      browser.goto WatirSpec.url_for 'index.html'
+      expect(browser.cookies.to_a).to eq []
+    end
 
-  describe '#[]' do
-    before do
+    it 'gets any cookies set' do
       browser.goto set_cookie_url
+
       verify_cookies_count 1
-    end
 
-    it 'returns cookie by symbol name' do
-      cookie = browser.cookies[:monster]
-      expect(cookie[:name]).to eq('monster')
-      expect(cookie[:value]).to eq('1')
+      cookie = browser.cookies.to_a.first
+      expect(cookie[:name]).to eq 'monster'
+      expect(cookie[:value]).to eq '1'
     end
 
-    it 'returns cookie by string name' do
-      cookie = browser.cookies['monster']
-      expect(cookie[:name]).to eq('monster')
-      expect(cookie[:value]).to eq('1')
+    describe '#[]' do
+      before do
+        browser.goto set_cookie_url
+        verify_cookies_count 1
+      end
+
+      it 'returns cookie by symbol name' do
+        cookie = browser.cookies[:monster]
+        expect(cookie[:name]).to eq('monster')
+        expect(cookie[:value]).to eq('1')
+      end
+
+      it 'returns cookie by string name' do
+        cookie = browser.cookies['monster']
+        expect(cookie[:name]).to eq('monster')
+        expect(cookie[:value]).to eq('1')
+      end
+
+      it 'returns nil if there is no cookie with such name' do
+        expect(browser.cookies[:non_monster]).to be_nil
+      end
     end
 
-    it 'returns nil if there is no cookie with such name' do
-      expect(browser.cookies[:non_monster]).to eq(nil)
+    it 'adds a cookie without options' do
+      browser.goto WatirSpec.url_for 'index.html'
+      verify_cookies_count 0
+
+      browser.cookies.add 'foo', 'bar'
+      verify_cookies_count 1
     end
-  end
 
-  it 'adds a cookie without options' do
-    browser.goto WatirSpec.url_for 'index.html'
-    verify_cookies_count 0
+    it 'adds a cookie with a string expires value' do
+      browser.goto WatirSpec.url_for 'index.html'
 
-    browser.cookies.add 'foo', 'bar'
-    verify_cookies_count 1
-  end
+      expire_time = ::Time.now + 10_000
 
-  it 'adds a cookie with a string expires value' do
-    browser.goto WatirSpec.url_for 'index.html'
+      browser.cookies.add 'foo', 'bar', expires: expire_time.to_s
 
-    expire_time = Time.now + 10_000
+      cookie = browser.cookies[:foo]
+      expect(cookie[:expires]).to be_a(::Time)
+    end
 
-    browser.cookies.add 'foo', 'bar', expires: expire_time.to_s
+    it 'adds a cookie with path',
+       except: {browser: :ie, reason: 'path contains two slashes'} do
+      browser.goto WatirSpec.url_for 'index.html'
 
-    cookie = browser.cookies[:foo]
-    expect(cookie[:expires]).to be_kind_of(Time)
-  end
+      options = {path: '/set_cookie'}
+      browser.cookies.add 'path', 'b', options
 
-  it 'adds a cookie with path',
-     except: {browser: :ie, reason: 'path contains two slashes'} do
-    browser.goto WatirSpec.url_for 'index.html'
+      expect(browser.cookies.to_a).to be_empty
 
-    options = {path: '/set_cookie'}
-    browser.cookies.add 'path', 'b', options
+      browser.goto set_cookie_url
+      cookie = browser.cookies.to_a.find { |e| e[:name] == 'path' }
 
-    expect(browser.cookies.to_a).to be_empty
+      expect(cookie[:name]).to eq 'path'
+      expect(cookie[:value]).to eq 'b'
+      expect(cookie[:path]).to eq '/set_cookie'
+    end
 
-    browser.goto set_cookie_url
-    cookie = browser.cookies.to_a.find { |e| e[:name] == 'path' }
+    it 'adds a cookie with samesite value' do
+      browser.goto WatirSpec.url_for 'index.html'
 
-    expect(cookie[:name]).to eq 'path'
-    expect(cookie[:value]).to eq 'b'
-    expect(cookie[:path]).to eq '/set_cookie'
-  end
+      options = {same_site: 'Strict'}
+      browser.cookies.add 'samesite', 'strict', options
 
-  it 'adds a cookie with expiration' do
-    browser.goto WatirSpec.url_for 'index.html'
+      cookie = browser.cookies.to_a.find { |e| e[:name] == 'samesite' }
 
-    expires = Time.now + 10_000
-    options = {expires: expires}
+      expect(cookie[:name]).to eq 'samesite'
+      expect(cookie[:value]).to eq 'strict'
+      expect(cookie[:same_site]).to eq 'Strict'
+    end
 
-    browser.cookies.add 'expiration', 'b', options
-    cookie = browser.cookies.to_a.first
+    it 'adds a cookie with httponly value' do
+      browser.goto WatirSpec.url_for 'index.html'
 
-    expect(cookie[:name]).to eq 'expiration'
-    expect(cookie[:value]).to eq 'b'
+      options = {http_only: true}
+      browser.cookies.add 'httponly', 'true', options
 
-    expect((cookie[:expires]).to_i).to be_within(2).of(expires.to_i)
-  end
+      cookie = browser.cookies.to_a.find { |e| e[:name] == 'httponly' }
+
+      expect(cookie[:name]).to eq 'httponly'
+      expect(cookie[:value]).to eq 'true'
+      expect(cookie[:http_only]).to be true
+      expect(browser.execute_script('return document.cookie')).to be_empty
+    end
 
-  # Pending resolution of https://github.com/w3c/webdriver/issues/1571
-  it 'adding cookie with security does not raise exception but can not be retrieved',
-     except: [{browser: :firefox,
-               reason: 'https://github.com/mozilla/geckodriver/issues/1840'},
-              {browser: %i[chrome edge], platform: :windows}] do
-    browser.goto WatirSpec.url_for 'index.html'
+    it 'adds a cookie with expiration' do
+      browser.goto WatirSpec.url_for 'index.html'
 
-    options = {secure: true}
+      expires = ::Time.now + 10_000
+      options = {expires: expires}
 
-    browser.cookies.add 'secure', 'b', options
-    cookie = browser.cookies.to_a.find { |e| e[:name] == 'secure' }
-    expect(cookie).to be_nil
-  end
+      browser.cookies.add 'expiration', 'b', options
+      cookie = browser.cookies.to_a.first
 
-  it 'removes a cookie' do
-    browser.goto set_cookie_url
-    verify_cookies_count 1
+      expect(cookie[:name]).to eq 'expiration'
+      expect(cookie[:value]).to eq 'b'
 
-    browser.cookies.delete 'monster'
-    verify_cookies_count 0
-  end
+      expect((cookie[:expires]).to_i).to be_within(2).of(expires.to_i)
+    end
 
-  it 'clears all cookies' do
-    browser.goto set_cookie_url
-    browser.cookies.add 'foo', 'bar'
-    verify_cookies_count 2
+    # Pending resolution of https://github.com/w3c/webdriver/issues/1571
+    it 'adding cookie with security does not raise exception but can not be retrieved',
+       except: [{browser: :firefox,
+                 reason: 'https://github.com/mozilla/geckodriver/issues/1840'},
+                {browser: %i[chrome edge], platform: :windows}] do
+      browser.goto WatirSpec.url_for 'index.html'
 
-    browser.cookies.clear
-    verify_cookies_count 0
-  end
+      options = {secure: true}
 
-  context 'cookie file' do
-    let(:file) { "#{Dir.tmpdir}/cookies" }
+      browser.cookies.add 'secure', 'b', options
+      cookie = browser.cookies.to_a.find { |e| e[:name] == 'secure' }
+      expect(cookie).to be_nil
+    end
 
-    before do
+    it 'removes a cookie' do
       browser.goto set_cookie_url
-      browser.cookies.save file
+      verify_cookies_count 1
+
+      browser.cookies.delete 'monster'
+      verify_cookies_count 0
     end
 
-    describe '#save' do
-      it 'saves cookies to file' do
-        expect(File.read(file)).to eq(browser.cookies.to_a.to_yaml)
-      end
+    it 'clears all cookies' do
+      browser.goto set_cookie_url
+      browser.cookies.add 'foo', 'bar'
+      verify_cookies_count 2
+
+      browser.cookies.clear
+      verify_cookies_count 0
     end
 
-    describe '#load', except: {browser: :ie} do
-      it 'loads cookies from file' do
-        browser.cookies.clear
-        browser.cookies.load file
-        expected = browser.cookies.to_a
-        actual = YAML.safe_load(File.read(file), permitted_classes: [Symbol])
+    context 'when using file' do
+      let(:file) { "#{Dir.tmpdir}/cookies" }
 
-        expected.each { |cookie| cookie.delete(:expires) }
-        actual.each { |cookie| cookie.delete(:expires) }
+      before do
+        browser.goto set_cookie_url
+        browser.cookies.save file
+      end
 
-        expect(actual).to eq(expected)
+      describe '#save' do
+        it 'saves cookies to file' do
+          expect(File.read(file)).to eq(browser.cookies.to_a.to_yaml)
+        end
+      end
+
+      describe '#load', except: {browser: :ie} do
+        it 'loads cookies from file' do
+          browser.cookies.clear
+          browser.cookies.load file
+          expected = browser.cookies.to_a
+          actual = YAML.safe_load_file(file, permitted_classes: [::Symbol])
+
+          expected.each { |cookie| cookie.delete(:expires) }
+          actual.each { |cookie| cookie.delete(:expires) }
+
+          expect(actual).to eq(expected)
+        end
       end
     end
-  end
 
-  def set_cookie_url
-    # add timestamp to url to avoid caching in IE8
-    WatirSpec.url_for('set_cookie/index.html') + "?t=#{Time.now.to_i + Time.now.usec}"
-  end
+    def set_cookie_url
+      # add timestamp to url to avoid caching in IE8
+      WatirSpec.url_for('set_cookie/index.html') + "?t=#{::Time.now.to_i + ::Time.now.usec}"
+    end
 
-  def verify_cookies_count(expected_size)
-    cookies = browser.cookies.to_a
-    msg = "expected #{expected_size} cookies, got #{cookies.size}: #{cookies.inspect}"
-    expect(cookies.size).to eq(expected_size), msg
+    def verify_cookies_count(expected_size)
+      cookies = browser.cookies.to_a
+      msg = "expected #{expected_size} cookies, got #{cookies.size}: #{cookies.inspect}"
+      expect(cookies.size).to eq(expected_size), msg
+    end
   end
 end

data/spec/watirspec/drag_and_drop_spec.rb

@@ -2,35 +2,37 @@
 
 require 'watirspec_helper'
 
-describe 'Element' do
-  context 'drag and drop', except: {browser: :ie} do
-    before { browser.goto WatirSpec.url_for('drag_and_drop.html') }
+module Watir
+  describe Element do
+    describe 'using drag and drop', except: {browser: :ie} do
+      before { browser.goto WatirSpec.url_for('drag_and_drop.html') }
 
-    let(:draggable) { browser.div id: 'draggable' }
-    let(:droppable) { browser.div id: 'droppable' }
+      let(:draggable) { browser.div id: 'draggable' }
+      let(:droppable) { browser.div id: 'droppable' }
 
-    it 'can drag and drop an element onto another' do
-      expect(droppable.text).to include 'Drop here'
-      draggable.drag_and_drop_on droppable
-      expect(droppable.text).to include 'Dropped!'
-    end
+      it 'can drag and drop an element onto another' do
+        expect(droppable.text).to include 'Drop here'
+        draggable.drag_and_drop_on droppable
+        expect(droppable.text).to include 'Dropped!'
+      end
 
-    it 'can drag and drop an element onto another with specified scroll position' do
-      expect(droppable.text).to include 'Drop here'
-      draggable.drag_and_drop_on droppable, scroll_to: :center
-      expect(droppable.text).to include 'Dropped!'
-    end
+      it 'can drag and drop an element onto another with specified scroll position' do
+        expect(droppable.text).to include 'Drop here'
+        draggable.drag_and_drop_on droppable, scroll_to: :center
+        expect(droppable.text).to include 'Dropped!'
+      end
 
-    it 'can drag an element by the given offset' do
-      expect(droppable.text).to include 'Drop here'
-      draggable.drag_and_drop_by 200, 50
-      expect(droppable.text).to include 'Dropped!'
-    end
+      it 'can drag an element by the given offset' do
+        expect(droppable.text).to include 'Drop here'
+        draggable.drag_and_drop_by 200, 50
+        expect(droppable.text).to include 'Dropped!'
+      end
 
-    it 'can drag an element by the given offset with specified scroll position' do
-      expect(droppable.text).to include 'Drop here'
-      draggable.drag_and_drop_by 200, 50, scroll_to: :center
-      expect(droppable.text).to include 'Dropped!'
+      it 'can drag an element by the given offset with specified scroll position' do
+        expect(droppable.text).to include 'Drop here'
+        draggable.drag_and_drop_by 200, 50, scroll_to: :center
+        expect(droppable.text).to include 'Dropped!'
+      end
     end
   end
 end

data/spec/watirspec/element_hidden_spec.rb

@@ -2,79 +2,85 @@
 
 require 'watirspec_helper'
 
-describe Watir::Locators::Element::Locator do
-  describe 'Visible Elements' do
-    before do
-      browser.goto(WatirSpec.url_for('wait.html'))
-    end
+module Watir
+  module Locators
+    class Element
+      describe Locator do
+        describe 'Visible Elements' do
+          before do
+            browser.goto(WatirSpec.url_for('wait.html'))
+          end
 
-    context 'when true' do
-      it 'finds single element' do
-        element = browser.body.element(visible: true)
-        expect(element.id).to eq 'foo'
-      end
+          context 'when true' do
+            it 'finds single element' do
+              element = browser.body.element(visible: true)
+              expect(element.id).to eq 'foo'
+            end
 
-      it 'handles tag_name and index' do
-        element = browser.div(visible: true, index: 1)
-        expect(element.id).to eq 'buttons'
-      end
+            it 'handles tag_name and index' do
+              element = browser.div(visible: true, index: 1)
+              expect(element.id).to eq 'buttons'
+            end
 
-      it 'handles :tag_name and a single regexp attribute' do
-        element = browser.div(visible: true, id: /ons/)
-        expect(element.id).to eq 'buttons'
-      end
+            it 'handles :tag_name and a single regexp attribute' do
+              element = browser.div(visible: true, id: /ons/)
+              expect(element.id).to eq 'buttons'
+            end
 
-      it 'handles :xpath' do
-        element = browser.element(visible: true, xpath: './/div[@id="foo"]')
-        expect(element.id).to eq 'foo'
-      end
+            it 'handles :xpath' do
+              element = browser.element(visible: true, xpath: './/div[@id="foo"]')
+              expect(element.id).to eq 'foo'
+            end
 
-      it 'handles :css' do
-        element = browser.element(visible: true, css: 'div#foo')
-        expect(element.id).to eq 'foo'
-      end
+            it 'handles :css' do
+              element = browser.element(visible: true, css: 'div#foo')
+              expect(element.id).to eq 'foo'
+            end
 
-      it 'handles in collections' do
-        elements = browser.divs(visible: true)
-        expect(elements.size).to eq 3
-      end
-    end
+            it 'handles in collections' do
+              elements = browser.divs(visible: true)
+              expect(elements.size).to eq 3
+            end
+          end
 
-    context 'when false' do
-      it 'finds single element' do
-        element = browser.body.element(visible: false)
-        expect(element.id).to eq 'bar'
-      end
+          context 'when false' do
+            it 'finds single element' do
+              element = browser.body.element(visible: false)
+              expect(element.id).to eq 'bar'
+            end
 
-      it 'handles tag_name and index' do
-        element = browser.div(visible: false, index: 1)
-        expect(element.id).to eq 'also_hidden'
-      end
+            it 'handles tag_name and index' do
+              element = browser.div(visible: false, index: 1)
+              expect(element.id).to eq 'also_hidden'
+            end
 
-      it 'handles :tag_name and a single regexp attribute' do
-        element = browser.div(visible: false, id: /_/)
-        expect(element.id).to eq 'also_hidden'
-      end
+            it 'handles :tag_name and a single regexp attribute' do
+              element = browser.div(visible: false, id: /_/)
+              expect(element.id).to eq 'also_hidden'
+            end
 
-      it 'handles :xpath' do
-        element = browser.element(visible: false, xpath: './/div[@id="bar"]')
-        expect(element.id).to eq 'bar'
-      end
+            it 'handles :xpath' do
+              element = browser.element(visible: false, xpath: './/div[@id="bar"]')
+              expect(element.id).to eq 'bar'
+            end
 
-      it 'handles :css' do
-        element = browser.element(visible: false, css: 'div#bar')
-        expect(element.id).to eq 'bar'
-      end
+            it 'handles :css' do
+              element = browser.element(visible: false, css: 'div#bar')
+              expect(element.id).to eq 'bar'
+            end
 
-      it 'handles in collections' do
-        elements = browser.divs(visible: false)
-        expect(elements.size).to eq 3
-      end
-    end
+            it 'handles in collections' do
+              elements = browser.divs(visible: false)
+              expect(elements.size).to eq 3
+            end
+          end
 
-    it 'raises exception when value is not Boolean' do
-      msg = 'expected one of [TrueClass, FalseClass], got "true":String'
-      expect { browser.body.element(visible: 'true') }.to raise_exception(TypeError, msg)
+          it 'raises exception when value is not Boolean' do
+            msg = 'expected one of [TrueClass, FalseClass], got "true":String'
+            expect { browser.body.element(visible: 'true') }.to raise_exception(TypeError, msg)
+          end
+        end
+      end
     end
   end
 end

data/spec/watirspec/elements/area_spec.rb

@@ -2,66 +2,68 @@
 
 require 'watirspec_helper'
 
-describe 'Area' do
-  before :each do
-    browser.goto(WatirSpec.url_for('images.html'))
-  end
+module Watir
+  describe Area do
+    before do
+      browser.goto(WatirSpec.url_for('images.html'))
+    end
 
-  # Exists method
-  describe '#exist?' do
-    it 'returns true if the area exists' do
-      expect(browser.area(id: 'NCE')).to exist
-      expect(browser.area(id: /NCE/)).to exist
-      expect(browser.area(title: 'Tables')).to exist
-      expect(browser.area(title: /Tables/)).to exist
-      expect(browser.area(href: 'tables.html')).to exist
-      expect(browser.area(href: /tables/)).to exist
+    # Exists method
+    describe '#exist?' do
+      it 'returns true if the area exists' do
+        expect(browser.area(id: 'NCE')).to exist
+        expect(browser.area(id: /NCE/)).to exist
+        expect(browser.area(title: 'Tables')).to exist
+        expect(browser.area(title: /Tables/)).to exist
+        expect(browser.area(href: 'tables.html')).to exist
+        expect(browser.area(href: /tables/)).to exist
 
-      expect(browser.area(index: 0)).to exist
-      expect(browser.area(xpath: "//area[@id='NCE']")).to exist
-    end
+        expect(browser.area(index: 0)).to exist
+        expect(browser.area(xpath: "//area[@id='NCE']")).to exist
+      end
 
-    it 'returns the first area if given no args' do
-      expect(browser.area).to exist
-    end
+      it 'returns the first area if given no args' do
+        expect(browser.area).to exist
+      end
 
-    it "returns false if the area doesn't exist" do
-      expect(browser.area(id: 'no_such_id')).to_not exist
-      expect(browser.area(id: /no_such_id/)).to_not exist
-      expect(browser.area(title: 'no_such_title')).to_not exist
-      expect(browser.area(title: /no_such_title/)).to_not exist
+      it "returns false if the area doesn't exist" do
+        expect(browser.area(id: 'no_such_id')).not_to exist
+        expect(browser.area(id: /no_such_id/)).not_to exist
+        expect(browser.area(title: 'no_such_title')).not_to exist
+        expect(browser.area(title: /no_such_title/)).not_to exist
 
-      expect(browser.area(href: 'no-tables.html')).to_not exist
-      expect(browser.area(href: /no-tables/)).to_not exist
+        expect(browser.area(href: 'no-tables.html')).not_to exist
+        expect(browser.area(href: /no-tables/)).not_to exist
 
-      expect(browser.area(index: 1337)).to_not exist
-      expect(browser.area(xpath: "//area[@id='no_such_id']")).to_not exist
-    end
+        expect(browser.area(index: 1337)).not_to exist
+        expect(browser.area(xpath: "//area[@id='no_such_id']")).not_to exist
+      end
 
-    it "raises TypeError when 'what' argument is invalid" do
-      expect { browser.area(id: 3.14).exists? }.to raise_error(TypeError)
+      it "raises TypeError when 'what' argument is invalid" do
+        expect { browser.area(id: 3.14).exists? }.to raise_error(TypeError)
+      end
     end
-  end
 
-  # Attribute methods
-  describe '#id' do
-    it 'returns the id attribute' do
-      expect(browser.area(index: 0).id).to eq 'NCE'
-    end
+    # Attribute methods
+    describe '#id' do
+      it 'returns the id attribute' do
+        expect(browser.area(index: 0).id).to eq 'NCE'
+      end
 
-    it "returns an empty string if the element exists and the attribute doesn't" do
-      expect(browser.area(index: 2).id).to eq ''
-    end
+      it "returns an empty string if the element exists and the attribute doesn't" do
+        expect(browser.area(index: 2).id).to eq ''
+      end
 
-    it "raises UnknownObjectException if the area doesn't exist" do
-      expect { browser.area(id: 'no_such_id').id }.to raise_unknown_object_exception
-      expect { browser.area(index: 1337).id }.to raise_unknown_object_exception
+      it "raises UnknownObjectException if the area doesn't exist" do
+        expect { browser.area(id: 'no_such_id').id }.to raise_unknown_object_exception
+        expect { browser.area(index: 1337).id }.to raise_unknown_object_exception
+      end
     end
-  end
 
-  describe '#respond_to?' do
-    it 'returns true for all attribute methods' do
-      expect(browser.area(index: 0)).to respond_to(:id)
+    describe '#respond_to?' do
+      it 'returns true for all attribute methods' do
+        expect(browser.area(index: 0)).to respond_to(:id)
+      end
     end
   end
 end