watir 7.0.0.beta1 → 7.0.0.beta5

data/spec/watirspec/elements/frame_spec.rb

@@ -47,15 +47,13 @@ describe 'Frame' do
       expect(browser.frame(xpath: "//frame[@id='no_such_id']")).to_not exist
     end
 
-    bug 'https://bugzilla.mozilla.org/show_bug.cgi?id=1255946', :firefox do
-      it 'handles nested frames' do
-        browser.goto(WatirSpec.url_for('nested_frames.html'))
+    it 'handles nested frames' do
+      browser.goto(WatirSpec.url_for('nested_frames.html'))
 
-        browser.frame(id: 'two').frame(id: 'three').link(id: 'four').click
+      browser.frame(id: 'two').frame(id: 'three').link(id: 'four').click
 
-        Watir::Wait.until { browser.title == 'definition_lists' }
-        expect { browser.goto(WatirSpec.url_for('nested_frames.html')) }.to_not raise_exception
-      end
+      browser.wait_until(title: 'definition_lists')
+      expect { browser.goto(WatirSpec.url_for('nested_frames.html')) }.to_not raise_exception
     end
 
     it "raises TypeError when 'what' argument is invalid" do
@@ -88,24 +86,21 @@ describe 'Frame' do
     expect(browser.frame(index: 0).text_field(name: 'senderElement').value).to eq 'new value'
   end
 
-  bug 'Safari does not strip text', :safari do
-    it "can access the frame's parent element after use" do
-      el = browser.frameset
-      el.frame.text_field.value
-      expect(el.attribute_value('cols')).to be_kind_of(String)
-    end
+  it "can access the frame's parent element after use" do
+    el = browser.frameset
+    el.frame.text_field.value
+    expect(el.attribute_value('cols')).to be_kind_of(String)
   end
 
   describe '#execute_script' do
-    bug 'Safari does not strip text', :safari do
-      it 'executes the given javascript in the specified frame' do
-        frame = browser.frame(index: 0)
-        expect(frame.div(id: 'set_by_js').text).to eq ''
-        inner_html = 'Art consists of limitation. The most beautiful part of every picture is the frame.'
-        frame.execute_script(%{document.getElementById('set_by_js').innerHTML = '#{inner_html}'})
-        text = 'Art consists of limitation. The most beautiful part of every picture is the frame.'
-        expect(frame.div(id: 'set_by_js').text).to eq text
-      end
+    it 'executes the given javascript in the specified frame',
+       except: {browser: :safari, reason: 'Safari does not strip text'} do
+      frame = browser.frame(index: 0)
+      expect(frame.div(id: 'set_by_js').text).to eq ''
+      inner_html = 'Art consists of limitation. The most beautiful part of every picture is the frame.'
+      frame.execute_script(%{document.getElementById('set_by_js').innerHTML = '#{inner_html}'})
+      text = 'Art consists of limitation. The most beautiful part of every picture is the frame.'
+      expect(frame.div(id: 'set_by_js').text).to eq text
     end
   end
 

data/spec/watirspec/elements/iframe_spec.rb

@@ -9,18 +9,13 @@ describe 'IFrame' do
     browser.goto(WatirSpec.url_for('iframes.html'))
   end
 
-  not_compliant_on :safari do
-    bug 'Firefox 58 broke this, appears to be working in Nightly',
-        %i[firefox linux] do
-      it 'handles crossframe javascript' do
-        browser.goto WatirSpec.url_for('iframes.html')
+  it 'handles crossframe javascript' do
+    browser.goto WatirSpec.url_for('iframes.html')
 
-        expect(browser.iframe(id: 'iframe_1').text_field(name: 'senderElement').value).to eq 'send_this_value'
-        expect(browser.iframe(id: 'iframe_2').text_field(name: 'recieverElement').value).to eq 'old_value'
-        browser.iframe(id: 'iframe_1').button(id: 'send').click
-        expect(browser.iframe(id: 'iframe_2').text_field(name: 'recieverElement').value).to eq 'send_this_value'
-      end
-    end
+    expect(browser.iframe(id: 'iframe_1').text_field(name: 'senderElement').value).to eq 'send_this_value'
+    expect(browser.iframe(id: 'iframe_2').text_field(name: 'recieverElement').value).to eq 'old_value'
+    browser.iframe(id: 'iframe_1').button(id: 'send').click
+    expect(browser.iframe(id: 'iframe_2').text_field(name: 'recieverElement').value).to eq 'send_this_value'
   end
 
   it 'locates an element defined by Selenium Element' do
@@ -116,13 +111,13 @@ describe 'IFrame' do
       expect(browser.iframe(id: 'no_such_id').element).to_not exist
     end
 
-    bug 'https://bugzilla.mozilla.org/show_bug.cgi?id=1255946', :firefox do
-      it 'handles nested iframes' do
-        browser.goto(WatirSpec.url_for('nested_iframes.html'))
-        browser.iframe(id: 'two').iframe(id: 'three').link(id: 'four').click
+    it 'handles nested iframes' do
+      browser.goto(WatirSpec.url_for('nested_iframes.html'))
+      browser.iframe(id: 'two').iframe(id: 'three').link(id: 'four').click
 
-        Watir::Wait.until { browser.title == 'definition_lists' }
-      end
+      expect {
+        browser.wait_until { |b| b.title == 'definition_lists' }
+      }.not_to raise_exception
     end
 
     it "raises TypeError when 'what' argument is invalid" do
@@ -200,16 +195,15 @@ describe 'IFrame' do
   end
 
   describe '#execute_script' do
-    bug 'Safari does not strip text', :safari do
-      it 'executes the given javascript in the specified frame' do
-        frame = browser.iframe(index: 0)
-        expect(frame.div(id: 'set_by_js').text).to eq ''
-        inner_html = 'Art consists of limitation. The most beautiful part of every picture is the frame.'
-        script = "document.getElementById('set_by_js').innerHTML = '#{inner_html}'"
-        frame.execute_script script
-        text = 'Art consists of limitation. The most beautiful part of every picture is the frame.'
-        expect(frame.div(id: 'set_by_js').text).to eq text
-      end
+    it 'executes the given javascript in the specified frame',
+       except: {browser: :safari, reason: 'Safari does not strip text'} do
+      frame = browser.iframe(index: 0)
+      expect(frame.div(id: 'set_by_js').text).to eq ''
+      inner_html = 'Art consists of limitation. The most beautiful part of every picture is the frame.'
+      script = "document.getElementById('set_by_js').innerHTML = '#{inner_html}'"
+      frame.execute_script script
+      text = 'Art consists of limitation. The most beautiful part of every picture is the frame.'
+      expect(frame.div(id: 'set_by_js').text).to eq text
     end
   end
 

data/spec/watirspec/elements/ins_spec.rb

@@ -94,18 +94,16 @@ describe 'Ins' do
   end
 
   # Other
-  not_compliant_on :headless do
-    describe '#click' do
-      it 'fires events' do
-        expect(browser.ins(class: 'footer').text).to_not include('Javascript')
-        browser.ins(class: 'footer').click
-        expect(browser.ins(class: 'footer').text).to include('Javascript')
-      end
-
-      it "raises UnknownObjectException if the ins doesn't exist" do
-        expect { browser.ins(id: 'no_such_id').click }.to raise_unknown_object_exception
-        expect { browser.ins(title: 'no_such_title').click }.to raise_unknown_object_exception
-      end
+  describe '#click', except: {headless: true} do
+    it 'fires events' do
+      expect(browser.ins(class: 'footer').text).to_not include('Javascript')
+      browser.ins(class: 'footer').click
+      expect(browser.ins(class: 'footer').text).to include('Javascript')
+    end
+
+    it "raises UnknownObjectException if the ins doesn't exist" do
+      expect { browser.ins(id: 'no_such_id').click }.to raise_unknown_object_exception
+      expect { browser.ins(title: 'no_such_title').click }.to raise_unknown_object_exception
     end
   end
 end

data/spec/watirspec/elements/link_spec.rb

@@ -14,9 +14,7 @@ describe 'Link' do
       expect(browser.link(title: /link_title_2/)).to exist
       expect(browser.link(text: 'Link 2')).to exist
       expect(browser.link(text: /Link 2/i)).to exist
-      not_compliant_on :internet_explorer do
-        expect(browser.link(href: 'non_control_elements.html')).to exist
-      end
+      expect(browser.link(href: 'non_control_elements.html')).to exist
       expect(browser.link(href: /non_control_elements.html/)).to exist
       expect(browser.link(index: 1)).to exist
       expect(browser.link(xpath: "//a[@id='link_2']")).to exist
@@ -123,35 +121,36 @@ describe 'Link' do
   end
 
   # Manipulation methods
+  # Note: the #wait_until calls are hacks for Safari specifically
   describe '#click' do
     it 'finds an existing link by (text: String) and clicks it' do
-      browser.link(text: 'Link 3').click
-      expect(browser.text.include?('User administration')).to be true
+      element = browser.link(text: 'Link 3')
+      element.wait_until { |link| !link.exist? || link.click }
+      expect(browser.h1(text: 'User administration')).to exist
     end
 
     it 'finds an existing link by (text: Regexp) and clicks it' do
-      browser.link(href: /forms_with_input_elements/).click
-      expect(browser.text.include?('User administration')).to be true
+      element = browser.link(href: /forms_with_input_elements/)
+      element.wait_until { |link| !link.exist? || link.click }
+      expect(browser.h1(text: 'User administration')).to exist
     end
 
-    bug 'sometimes safari does not work on the first click', :safari do
-      it 'finds an existing link by (index: Integer) and clicks it' do
-        browser.link(index: 2).click
-        expect(browser.text.include?('User administration')).to be true
-      end
+    it 'finds an existing link by (index: Integer) and clicks it' do
+      element = browser.link(index: 2)
+      element.wait_until { |link| !link.exist? || link.click }
+      expect(browser.h1(text: 'User administration')).to exist
     end
 
     it "raises an UnknownObjectException if the link doesn't exist" do
       expect { browser.link(index: 1337).click }.to raise_unknown_object_exception
     end
 
-    bug 'Safari throws a not interactable error', :safari do
-      it 'clicks a link with no text content but an img child' do
-        browser.goto WatirSpec.url_for('images.html')
-        browser.link(href: /definition_lists.html/).click
-        Watir::Wait.while { browser.title == 'Images' || browser.title == '' }
-        expect(browser.title).to eq 'definition_lists'
-      end
+    it 'clicks a link with no text content but an img child',
+       except: {browser: :safari, reason: 'Safari throws a not interactable error'} do
+      browser.goto WatirSpec.url_for('images.html')
+      browser.link(href: /definition_lists.html/).click
+      browser.wait_while(title: /^(Images|)$/)
+      expect(browser.title).to eq 'definition_lists'
     end
   end
 
@@ -167,14 +166,13 @@ describe 'Link' do
       expect(browser.link(visible_text: /Link 2/, class: 'external')).to exist
     end
 
-    bug 'Safari is not filtering out hidden text', :safari do
-      it 'finds links in spite of hidden text' do
-        browser.goto WatirSpec.url_for('non_control_elements.html')
+    it 'finds links in spite of hidden text',
+       except: {browser: :safari, reason: 'Safari is not filtering out hidden text'} do
+      browser.goto WatirSpec.url_for('non_control_elements.html')
 
-        expect(browser.link(visible_text: 'some visible')).to exist
-        expect(browser.link(visible_text: 'none visible')).not_to exist
-        expect(browser.link(visible_text: /none visible/)).not_to exist
-      end
+      expect(browser.link(visible_text: 'some visible')).to exist
+      expect(browser.link(visible_text: 'none visible')).not_to exist
+      expect(browser.link(visible_text: /none visible/)).not_to exist
     end
 
     it 'raises exception unless value is a String or a RegExp' do

data/spec/watirspec/elements/links_spec.rb

@@ -49,15 +49,14 @@ describe 'Links' do
       expect(container.links(visible_text: /some visible/).count).to eq(1)
     end
 
-    bug 'Safari is not filtering out hidden text', :safari do
-      it 'finds links in spite of hidden text' do
-        browser.goto WatirSpec.url_for('non_control_elements.html')
-        container = browser.div(id: 'visible_text')
-
-        expect(container.divs(visible_text: 'some visible').count).to eq(1)
-        expect(container.divs(visible_text: 'none visible').count).to eq(0)
-        expect(container.divs(visible_text: /none visible/).count).to eq(0)
-      end
+    it 'finds links in spite of hidden text',
+       except: {browser: :safari, reason: 'Safari is not filtering out hidden text'} do
+      browser.goto WatirSpec.url_for('non_control_elements.html')
+      container = browser.div(id: 'visible_text')
+
+      expect(container.divs(visible_text: 'some visible').count).to eq(1)
+      expect(container.divs(visible_text: 'none visible').count).to eq(0)
+      expect(container.divs(visible_text: /none visible/).count).to eq(0)
     end
   end
 end

data/spec/watirspec/elements/radio_spec.rb

@@ -205,20 +205,17 @@ describe 'Radio' do
       expect(messages).to eq ['clicked: new_user_newsletter_no', 'clicked: new_user_newsletter_yes']
     end
 
-    # http://webbugtrack.blogspot.com/2007/11/bug-193-onchange-does-not-fire-properly.html
-    not_compliant_on :internet_explorer do
-      it 'fires the onchange event' do
-        browser.radio(value: 'certainly').set
-        expect(messages).to eq ['changed: new_user_newsletter']
-
-        browser.radio(value: 'certainly').set
-        expect(messages).to eq ['changed: new_user_newsletter'] # no event fired here - didn't change
-
-        browser.radio(value: 'yes').set
-        browser.radio(value: 'certainly').set
-        list = ['changed: new_user_newsletter', 'clicked: new_user_newsletter_yes', 'changed: new_user_newsletter']
-        expect(messages).to eq list
-      end
+    it 'fires the onchange event' do
+      browser.radio(value: 'certainly').set
+      expect(messages).to eq ['changed: new_user_newsletter']
+
+      browser.radio(value: 'certainly').set
+      expect(messages).to eq ['changed: new_user_newsletter'] # no event fired here - didn't change
+
+      browser.radio(value: 'yes').set
+      browser.radio(value: 'certainly').set
+      list = ['changed: new_user_newsletter', 'clicked: new_user_newsletter_yes', 'changed: new_user_newsletter']
+      expect(messages).to eq list
     end
 
     it "raises UnknownObjectException if the radio button doesn't exist" do

data/spec/watirspec/elements/select_list_spec.rb

@@ -220,107 +220,192 @@ describe 'SelectList' do
   end
 
   describe '#selected?' do
-    it 'returns true if the given option is selected by text' do
-      browser.select_list(name: 'new_user_country').select('Denmark')
+    it 'evaluates true by text' do
+      browser.select_list(name: 'new_user_country').select('1')
       expect(browser.select_list(name: 'new_user_country')).to be_selected('Denmark')
     end
 
-    it 'returns false if the given option is not selected by text' do
+    it 'evaluates false by text' do
       expect(browser.select_list(name: 'new_user_country')).to_not be_selected('Sweden')
     end
 
-    it 'returns true if the given option is selected by label' do
+    it 'evaluates true exclusively by text' do
+      browser.select_list(name: 'new_user_country').select('1')
+      expect(browser.select_list(name: 'new_user_country')).to be_selected(text: 'Denmark')
+    end
+
+    it 'evaluates false exclusively by text' do
+      expect(browser.select_list(name: 'new_user_country')).to_not be_selected(text: 'Sweden')
+    end
+
+    it 'evaluates true by label' do
       browser.select_list(name: 'new_user_country').select('Germany')
       expect(browser.select_list(name: 'new_user_country')).to be_selected('Germany')
     end
 
-    it 'returns false if the given option is not selected by label' do
+    it 'evaluates false by label' do
       expect(browser.select_list(name: 'new_user_country')).to_not be_selected('Germany')
     end
 
-    it "raises UnknownObjectException if the option doesn't exist" do
+    it 'evaluates true exclusively by label' do
+      browser.select_list(name: 'new_user_country').select('Germany')
+      expect(browser.select_list(name: 'new_user_country')).to be_selected(label: 'Germany')
+    end
+
+    it 'evaluates false exclusively by label' do
+      expect(browser.select_list(name: 'new_user_country')).to_not be_selected(label: 'Germany')
+    end
+
+    it 'evaluates true by value' do
+      browser.select_list(name: 'new_user_country').select('USA')
+      expect(browser.select_list(name: 'new_user_country')).to be_selected('5')
+    end
+
+    it 'evaluates false by value' do
+      expect(browser.select_list(name: 'new_user_country')).to_not be_selected('5')
+    end
+
+    it 'evaluates true exclusively by value' do
+      browser.select_list(name: 'new_user_country').select('USA')
+      expect(browser.select_list(name: 'new_user_country')).to be_selected(value: '5')
+    end
+
+    it 'evaluates false exclusively by value' do
+      expect(browser.select_list(name: 'new_user_country')).to_not be_selected(value: '5')
+    end
+
+    it "raises NoValueFoundException if the option doesn't exist" do
       expect { browser.select_list(name: 'new_user_country').selected?('missing_option') }
-        .to raise_unknown_object_exception
+        .to raise_no_value_found_exception
     end
   end
 
-  describe '#select' do
-    context 'when finding by value' do
-      it 'selects an option with a String' do
-        browser.select_list(name: 'new_user_languages').clear
-        browser.select_list(name: 'new_user_languages').select('2')
-        expect(browser.select_list(name: 'new_user_languages').selected_options.map(&:text)).to eq %w[EN]
+  describe '#select method' do
+    context 'working with multiple select list' do
+      before do
+        @select_list = browser.select_list(name: 'new_user_languages')
+        @select_list.clear
       end
 
-      it 'selects an option with a Regexp' do
-        browser.select_list(name: 'new_user_languages').clear
-        browser.select_list(name: 'new_user_languages').select(/2|3/)
-        expect(browser.select_list(name: 'new_user_languages').selected_options.map(&:text)).to eq %w[EN]
+      context 'when finding by value' do
+        it 'selects an option with a String' do
+          @select_list.select('2')
+          expect(@select_list.selected_options.first.text).to eq 'EN'
+        end
+
+        it 'selects an option with a Number' do
+          @select_list.select(2)
+          expect(@select_list.selected_options.first.text).to eq 'EN'
+        end
+
+        it 'selects an option with a Regexp' do
+          @select_list.select(/2|3/)
+          expect(@select_list.selected_options.first.text).to eq 'EN'
+        end
+
+        it 'uses keyword with a String' do
+          @select_list.select(value: '2')
+          expect(@select_list.selected_options.first.text).to eq 'EN'
+        end
+
+        it 'uses keyword with a Number' do
+          @select_list.select(value: 2)
+          expect(@select_list.selected_options.first.text).to eq 'EN'
+        end
+
+        it 'uses keyword with a Regexp' do
+          @select_list.select(value: /2|3/)
+          expect(@select_list.selected_options.first.text).to eq 'EN'
+        end
       end
-    end
 
-    context 'when finding by text' do
-      it 'selects an option with a String' do
-        browser.select_list(name: 'new_user_country').select('Denmark')
-        expect(browser.select_list(name: 'new_user_country').selected_options.map(&:text)).to eq ['Denmark']
+      context 'when finding by text' do
+        it 'selects an option with a String' do
+          @select_list.select('Norwegian')
+          expect(@select_list.selected_options.first.value).to eq '3'
+        end
+
+        it 'selects an option with a Regexp' do
+          @select_list.select(/wegia/)
+          expect(@select_list.selected_options.first.value).to eq '3'
+        end
+
+        it 'uses keyword with a String' do
+          @select_list.select(text: 'Norwegian')
+          expect(@select_list.selected_options.first.value).to eq '3'
+        end
+
+        it 'uses keyword with a Regexp' do
+          @select_list.select(text: /wegia/)
+          expect(@select_list.selected_options.first.value).to eq '3'
+        end
       end
 
-      it 'selects an option with a Regexp' do
-        browser.select_list(name: 'new_user_country').select(/Denmark/)
-        expect(browser.select_list(name: 'new_user_country').selected_options.map(&:text)).to eq ['Denmark']
+      context 'when finding by label' do
+        it 'selects an option with a String' do
+          @select_list.select('NO')
+          expect(@select_list.selected_options.first.value).to eq '3'
+        end
+
+        it 'selects an option with a Regexp' do
+          @select_list.select(/^N/)
+          expect(@select_list.selected_options.first.value).to eq '3'
+        end
+
+        it 'uses keyword with a String' do
+          @select_list.select(label: 'NO')
+          expect(@select_list.selected_options.first.value).to eq '3'
+        end
+
+        it 'uses keyword with a Regexp' do
+          @select_list.select(label: /^N/)
+          expect(@select_list.selected_options.first.value).to eq '3'
+        end
       end
-    end
 
-    context 'when finding by label' do
-      it 'selects an option with a String' do
-        browser.select_list(name: 'new_user_languages').clear
-        browser.select_list(name: 'new_user_languages').select('NO')
-        expect(browser.select_list(name: 'new_user_languages').selected_options.map(&:text)).to eq ['NO']
+      it 'selects multiple options successively' do
+        @select_list.select('Danish')
+        @select_list.select('Swedish')
+        expect(@select_list.selected_options.map(&:text)).to eq %w[Danish Swedish]
       end
 
-      it 'selects an option with a Regexp' do
-        browser.select_list(name: 'new_user_languages').clear
-        browser.select_list(name: 'new_user_languages').select(/^N/)
-        expect(browser.select_list(name: 'new_user_languages').selected_options.map(&:text)).to eq ['NO']
+      it 'selects each item in an Array' do
+        @select_list.select(%w[Danish Swedish])
+        expect(@select_list.selected_options.map(&:text)).to eq %w[Danish Swedish]
       end
-    end
 
-    it 'selects multiple options successively' do
-      browser.select_list(name: 'new_user_languages').clear
-      browser.select_list(name: 'new_user_languages').select('Danish')
-      browser.select_list(name: 'new_user_languages').select('Swedish')
-      expect(browser.select_list(name: 'new_user_languages').selected_options.map(&:text)).to eq %w[Danish Swedish]
-    end
+      it 'selects each item in a parameter list' do
+        @select_list.select('Danish', 'Swedish')
+        expect(@select_list.selected_options.map(&:text)).to eq %w[Danish Swedish]
+      end
 
-    bug 'Safari is returning click intercepted error', :safari do
-      it 'selects empty options' do
+      it 'selects empty options',
+         except: {browser: :safari, reason: 'Safari throwing ElementNotInteractableError'} do
         browser.select_list(id: 'delete_user_username').select('')
         expect(browser.select_list(id: 'delete_user_username').selected_options.map(&:text)).to eq ['']
       end
-    end
 
-    it 'returns the value selected' do
-      expect(browser.select_list(name: 'new_user_languages').select('Danish')).to eq 'Danish'
-    end
+      it 'returns the value selected' do
+        expect(@select_list.select('Danish')).to eq 'Danish'
+      end
 
-    it 'fires onchange event when selecting an item' do
-      browser.select_list(id: 'new_user_languages').select('Danish')
-      expect(messages).to eq ['changed language']
-    end
+      it 'fires onchange event when selecting or deselecting an item' do
+        @select_list.select('Danish')
+        expect(messages).to eq ['changed language', 'changed language', 'changed language']
+      end
 
-    it "doesn't fire onchange event when selecting an already selected item" do
-      browser.select_list(id: 'new_user_languages').clear # removes the two pre-selected options
-      browser.select_list(id: 'new_user_languages').select('English')
-      expect(messages.size).to eq 3
+      it "doesn't fire onchange event when selecting an already selected item" do
+        @select_list.select('English')
+        expect(messages.size).to eq 3
 
-      browser.select_list(id: 'new_user_languages').select('English')
-      expect(messages.size).to eq 3
+        @select_list.select('English')
+        expect(messages.size).to eq 3
+      end
     end
 
-    bug 'Safari is returning click intercepted error', :safari do
-      it 'returns an empty string when selecting an option that disappears when selected' do
-        expect(browser.select_list(id: 'obsolete').select('sweden')).to eq ''
-      end
+    it 'returns an empty string when selecting an option that disappears when selected',
+       except: {browser: :safari, reason: 'Safari throwing ElementNotInteractableError'} do
+      expect(browser.select_list(id: 'obsolete').select('sweden')).to eq ''
     end
 
     it 'selects options with a single-quoted value' do
@@ -342,15 +427,13 @@ describe 'SelectList' do
         .to raise_no_value_found_exception message
     end
 
-    bug 'Safari is returning object enabled instead of disabled', :safari do
-      it 'raises ObjectDisabledException if the option is disabled' do
-        expect { browser.select_list(name: 'new_user_languages').select('Russian') }
-          .to raise_object_disabled_exception
-      end
+    it 'raises ObjectDisabledException if the option is disabled', except: {browser: :safari} do
+      expect { browser.select_list(name: 'new_user_languages').select('Russian') }
+        .to raise_object_disabled_exception
     end
 
     it 'raises a TypeError if argument is not a String, Regexp or Numeric' do
-      expect { browser.select_list(id: 'new_user_languages').select({}) }.to raise_error(TypeError)
+      expect { browser.select_list(id: 'new_user_languages').select(true) }.to raise_error(TypeError)
     end
 
     context 'multiple options' do
@@ -408,61 +491,112 @@ describe 'SelectList' do
   end
 
   describe '#select!' do
-    context 'when finding by value' do
-      it 'selects an option with a String' do
-        browser.select_list(name: 'new_user_languages').clear
-        browser.select_list(name: 'new_user_languages').select!('2')
-        expect(browser.select_list(name: 'new_user_languages').selected_options.map(&:text)).to eq %w[EN]
+    context 'working with multiple select list' do
+      before do
+        @select_list = browser.select_list(name: 'new_user_languages')
+        @select_list.clear
       end
 
-      it 'selects an option with a Regex' do
-        browser.select_list(name: 'new_user_languages').clear
-        browser.select_list(name: 'new_user_languages').select!(/2/)
-        expect(browser.select_list(name: 'new_user_languages').selected_options.map(&:text)).to eq %w[EN]
+      context 'when finding by value' do
+        it 'selects an option with a String' do
+          @select_list.select!('2')
+          expect(@select_list.selected_options.first.text).to eq 'EN'
+        end
+
+        it 'selects an option with a Number' do
+          @select_list.select!(2)
+          expect(@select_list.selected_options.first.text).to eq 'EN'
+        end
+
+        it 'selects an option with a Regexp' do
+          @select_list.select!(/2|3/)
+          expect(@select_list.selected_options.first.text).to eq 'EN'
+        end
+
+        it 'uses keyword with a String' do
+          @select_list.select!(value: '2')
+          expect(@select_list.selected_options.first.text).to eq 'EN'
+        end
+
+        it 'uses keyword with a Number' do
+          @select_list.select!(value: 2)
+          expect(@select_list.selected_options.first.text).to eq 'EN'
+        end
+
+        it 'uses keyword with a Regexp' do
+          @select_list.select!(value: /2|3/)
+          expect(@select_list.selected_options.first.text).to eq 'EN'
+        end
       end
-    end
 
-    context 'when finding by text' do
-      it 'selects an option with a String' do
-        browser.select_list(name: 'new_user_country').select!('Denmark')
-        expect(browser.select_list(name: 'new_user_country').selected_options.map(&:text)).to eq ['Denmark']
+      context 'when finding by text' do
+        it 'selects an option with a String' do
+          @select_list.select!('Danish')
+          expect(@select_list.selected_options.first.value).to eq '1'
+        end
+
+        it 'selects an option with a Regexp' do
+          @select_list.select!(/ani/)
+          expect(@select_list.selected_options.first.value).to eq '1'
+        end
+
+        it 'uses keyword with a String' do
+          @select_list.select!(text: 'Danish')
+          expect(@select_list.selected_options.first.value).to eq '1'
+        end
+
+        it 'uses keyword with a Regexp' do
+          @select_list.select!(text: /ani/)
+          expect(@select_list.selected_options.first.value).to eq '1'
+        end
       end
 
-      it 'selects an option with a Regexp' do
-        browser.select_list(name: 'new_user_country').select!(/Denmark/)
-        expect(browser.select_list(name: 'new_user_country').selected_options.map(&:text)).to eq ['Denmark']
+      context 'when finding by label' do
+        it 'selects an option with a String' do
+          @select_list.select!('NO')
+          expect(@select_list.selected_options.first.value).to eq '3'
+        end
+
+        it 'selects an option with a Regexp' do
+          @select_list.select!(/^N/)
+          expect(@select_list.selected_options.first.value).to eq '3'
+        end
+
+        it 'uses keyword with a String' do
+          @select_list.select!(label: 'NO')
+          expect(@select_list.selected_options.first.value).to eq '3'
+        end
+
+        it 'uses keyword with a Regexp' do
+          @select_list.select!(label: /^N/)
+          expect(@select_list.selected_options.first.value).to eq '3'
+        end
       end
-    end
 
-    context 'when finding by label' do
-      it 'selects an option with a String' do
-        browser.select_list(name: 'new_user_languages').clear
-        browser.select_list(name: 'new_user_languages').select!('NO')
-        expect(browser.select_list(name: 'new_user_languages').selected_options.map(&:text)).to eq ['NO']
+      it 'selects multiple options successively' do
+        @select_list.select!('Danish')
+        @select_list.select!('Swedish')
+        expect(@select_list.selected_options.map(&:text)).to eq %w[Danish Swedish]
       end
 
-      it 'selects an option with a Regexp' do
-        browser.select_list(name: 'new_user_languages').clear
-        browser.select_list(name: 'new_user_languages').select!(/NO/)
-        expect(browser.select_list(name: 'new_user_languages').selected_options.map(&:text)).to eq ['NO']
+      it 'selects each item in an Array' do
+        @select_list.select!(%w[Danish Swedish])
+        expect(@select_list.selected_options.map(&:text)).to eq %w[Danish Swedish]
       end
-    end
 
-    it 'selects multiple items successively' do
-      browser.select_list(name: 'new_user_languages').clear
-      browser.select_list(name: 'new_user_languages').select!('Danish')
-      browser.select_list(name: 'new_user_languages').select!('Swedish')
-      expect(browser.select_list(name: 'new_user_languages').selected_options.map(&:text)).to eq %w[Danish Swedish]
-    end
+      it 'selects each item in a parameter list' do
+        @select_list.select!('Danish', 'Swedish')
+        expect(@select_list.selected_options.map(&:text)).to eq %w[Danish Swedish]
+      end
 
-    it 'selects empty options' do
-      browser.select_list(id: 'delete_user_username').select!('')
-      expect(browser.select_list(id: 'delete_user_username').selected_options.map(&:text)).to eq ['']
-    end
+      it 'selects empty options' do
+        browser.select_list(id: 'delete_user_username').select!('')
+        expect(browser.select_list(id: 'delete_user_username').selected_options.map(&:text)).to eq ['']
+      end
 
-    it 'returns the value selected' do
-      browser.select_list(name: 'new_user_languages').clear
-      expect(browser.select_list(name: 'new_user_languages').select!('Danish')).to eq 'Danish'
+      it 'returns the value selected' do
+        expect(@select_list.select!('Danish')).to eq 'Danish'
+      end
     end
 
     it 'selects options with a single-quoted value' do
@@ -484,17 +618,14 @@ describe 'SelectList' do
         .to raise_no_value_found_exception
     end
 
-    bug 'Safari is returning object enabled instead of disabled', :safari do
-      it 'raises ObjectDisabledException if the option is disabled' do
-        browser.select_list(id: 'new_user_languages').clear
-        expect { browser.select_list(id: 'new_user_languages').select!('Russian') }
-          .to raise_object_disabled_exception
-      end
+    it 'raises ObjectDisabledException if the option is disabled', except: {browser: :safari} do
+      browser.select_list(id: 'new_user_languages').clear
+      expect { browser.select_list(name: 'new_user_languages').select!('Russian') }
+        .to raise_object_disabled_exception
     end
 
     it 'raises a TypeError if argument is not a String, Regexp or Numeric' do
-      browser.select_list(id: 'new_user_languages').clear
-      expect { browser.select_list(id: 'new_user_languages').select!({}) }.to raise_error(TypeError)
+      expect { browser.select_list(id: 'new_user_languages').select!(true) }.to raise_error(TypeError)
     end
 
     context 'multiple options' do