watir-webdriver 0.6.4 → 0.6.5

data/spec/browser_spec.rb

@@ -9,14 +9,13 @@ describe Watir::Browser do
     end
 
     it "takes a Driver instance as argument" do
-      mock_driver = mock(Selenium::WebDriver::Driver)
+      mock_driver = double(Selenium::WebDriver::Driver)
       Selenium::WebDriver::Driver.should_receive(:===).with(mock_driver).and_return(true)
-
-      lambda { Watir::Browser.new(mock_driver) }.should_not raise_error
+      expect { Watir::Browser.new(mock_driver) }.to_not raise_error
     end
 
     it "raises ArgumentError for invalid args" do
-      lambda { Watir::Browser.new(Object.new) }.should raise_error(ArgumentError)
+      expect { Watir::Browser.new(Object.new) }.to raise_error(ArgumentError)
     end
   end
 
@@ -25,25 +24,25 @@ describe Watir::Browser do
 
     it "wraps elements as Watir objects" do
       returned = browser.execute_script("return document.body")
-      returned.should be_kind_of(Watir::Body)
+      expect(returned).to be_kind_of(Watir::Body)
     end
 
     it "wraps elements in an array" do
       list = browser.execute_script("return [document.body];")
       list.size.should == 1
-      list.first.should be_kind_of(Watir::Body)
+      expect(list.first).to be_kind_of(Watir::Body)
     end
 
     it "wraps elements in a Hash" do
       hash = browser.execute_script("return {element: document.body};")
-      hash['element'].should be_kind_of(Watir::Body)
+      expect(hash['element']).to be_kind_of(Watir::Body)
     end
 
     it "wraps elements in a deep object" do
       hash = browser.execute_script("return {elements: [document.body], body: {element: document.body }}")
 
       hash['elements'].first.should be_kind_of(Watir::Body)
-      hash['body']['element'].should be_kind_of(Watir::Body)
+      expect(hash['body']['element']).to be_kind_of(Watir::Body)
     end
   end
 
@@ -52,7 +51,7 @@ describe Watir::Browser do
       browser.goto WatirSpec.url_for "forms_with_input_elements.html"
 
       browser.send_keys "hello"
-      browser.text_field(:id => "new_user_first_name").value.should == "hello"
+      expect(browser.text_field(:id => "new_user_first_name").value).to eq "hello"
     end
 
     it "sends keys to a frame" do
@@ -62,7 +61,7 @@ describe Watir::Browser do
 
       browser.frame.send_keys "hello"
 
-      tf.value.should == "hello"
+      expect(tf.value).to eq "hello"
     end
   end
 
@@ -71,7 +70,7 @@ describe Watir::Browser do
     b.goto WatirSpec.url_for "definition_lists.html"
     b.close
 
-    lambda { b.dl(:id => "experience-list").id }.should raise_error(Error, "browser was closed")
+    expect { b.dl(:id => "experience-list").id }.to raise_error(Error, "browser was closed")
   end
 
   describe "#wait_while" do
@@ -81,7 +80,7 @@ describe Watir::Browser do
       called = false
       browser.wait_while(3, "foo") { called = true }
 
-      called.should be_true
+      expect(called).to be_true
     end
   end
 
@@ -92,14 +91,14 @@ describe Watir::Browser do
       called = false
       browser.wait_until(3, "foo") { called = true }
 
-      called.should be_true
+      expect(called).to be_true
     end
   end
 
   describe "#wait" do
     it "waits until document.readyState == 'complete'" do
-      browser.should_receive(:ready_state).and_return('incomplete')
-      browser.should_receive(:ready_state).and_return('complete')
+      expect(browser).to receive(:ready_state).and_return('incomplete')
+      expect(browser).to receive(:ready_state).and_return('complete')
 
       browser.wait
     end
@@ -107,7 +106,8 @@ describe Watir::Browser do
 
   describe "#ready_state" do
     it "gets the document's readyState property" do
-      browser.should_receive(:execute_script).with('return document.readyState')
+      #browser.should_receive(:execute_script).with('return document.readyState')
+      expect(browser).to receive(:execute_script).with('return document.readyState')
       browser.ready_state
     end
   end
@@ -115,13 +115,13 @@ describe Watir::Browser do
   describe "#inspect" do
     it "works even if browser is closed" do
       browser.should_receive(:url).and_raise(Errno::ECONNREFUSED)
-      lambda { browser.inspect }.should_not raise_error
+      expect(browser.inspect).to_not raise_error
     end
   end
 
   describe '#screenshot' do
     it 'returns an instance of of Watir::Screenshot' do
-      browser.screenshot.should be_kind_of(Watir::Screenshot)
+      expect(browser.screenshot).to be_kind_of(Watir::Screenshot)
     end
   end
 end

data/spec/click_spec.rb

@@ -10,25 +10,25 @@ describe Watir::Element do
     let(:log)     { browser.element(:id => "log").ps.map { |e| e.text } }
 
     # TODO: make guards more flexible, in reality this currently only works on linux with native events
-    compliant_on [:webdriver, :firefox, :native_events] do 
+    compliant_on [:webdriver, :firefox, :native_events] do
       it "should perform a click with no modifier keys" do
         clicker.click
-        log.should == ["shift=false alt=false"]
+        expect(log).to eq ["shift=false alt=false"]
       end
 
       it "should perform a click with the shift key pressed" do
         clicker.click(:shift)
-        log.should == ["shift=true alt=false"]
+        expect(log).to eq ["shift=true alt=false"]
       end
 
       it "should perform a click with the alt key pressed" do
         clicker.click(:alt)
-        log.should == ["shift=false alt=true"]
+        expect(log).to eq ["shift=false alt=true"]
       end
 
       it "should perform a click with the shift and alt keys pressed" do
         clicker.click(:shift, :alt)
-        log.should == ["shift=true alt=true"]
+        expect(log).to eq ["shift=true alt=true"]
       end
     end
 

data/spec/container_spec.rb

@@ -11,29 +11,23 @@ describe Watir::Container do
     end
 
     it "converts 2-arg selector into a hash" do
-      @container.public_extract_selector([:how, 'what']).
-                 should == { :how => 'what' }
+      expect(@container.public_extract_selector([:how, 'what'])).to eq Hash[:how => 'what']
     end
 
     it "returns the hash given" do
-      @container.public_extract_selector([:how => "what"]).
-                 should == { :how => "what" }
+      expect(@container.public_extract_selector([:how => "what"])).to eq Hash[:how => "what"]
     end
 
     it "returns an empty hash if given no args" do
-      @container.public_extract_selector([]).should == {}
+      expect(@container.public_extract_selector([])).to eq Hash[]
     end
 
     it "raises ArgumentError if given 1 arg which is not a Hash" do
-      lambda {
-        @container.public_extract_selector([:how])
-      }.should raise_error(ArgumentError)
+      expect {@container.public_extract_selector([:how])}.to raise_error(ArgumentError)
     end
 
     it "raises ArgumentError if given > 2 args" do
-      lambda {
-        @container.public_extract_selector([:how, 'what', 'value'])
-      }.should raise_error(ArgumentError)
+      expect {@container.public_extract_selector([:how, 'what', 'value'])}.to raise_error(ArgumentError)
     end
 
   end

data/spec/element_locator_spec.rb

@@ -106,6 +106,17 @@ describe Watir::ElementLocator do
                    :data_name => "foo"
       end
 
+      it "handles aria-* attributes" do
+        if Watir.prefer_css?
+          expect_one :css, 'div[aria-label="foo"]'
+        else
+          expect_one :xpath, ".//div[@aria-label='foo']"
+        end
+
+        locate_one :tag_name  => "div",
+                   :aria_label => "foo"
+      end
+
       it "normalizes space for the :href attribute" do
         if Watir.prefer_css?
           expect_one :css, 'a[href~="foo"]'
@@ -146,11 +157,11 @@ describe Watir::ElementLocator do
         locate_one selector, Watir::Input.attributes
       end
 
-      it "does not use the label element for <option> elements" do
+      it "uses label attribute if it is valid for element" do
         expect_one :xpath, ".//option[@label='foo']"
 
-        locate_one :tag_name => "option",
-                   :label    => "foo"
+        selector = { :tag_name => "option", :label => "foo" }
+        locate_one selector, Watir::Option.attributes
       end
 
       it "translates ruby attribute names to content attribute names" do
@@ -184,7 +195,7 @@ describe Watir::ElementLocator do
           expect_all(:xpath, ".//div").and_return(elements)
         end
 
-        locate_one(:tag_name => "div", :class => /oob/).should == elements[1]
+        expect(locate_one(:tag_name => "div", :class => /oob/)).to eq elements[1]
       end
 
       it "handles :tag_name, :index and a single regexp attribute" do
@@ -205,7 +216,7 @@ describe Watir::ElementLocator do
           :index    => 1
         }
 
-        locate_one(selector).should == elements[1]
+        expect(locate_one(selector)).to eq elements[1]
       end
 
       it "handles mix of string and regexp attributes" do
@@ -227,7 +238,7 @@ describe Watir::ElementLocator do
           :title    => /baz/
         }
 
-        locate_one(selector).should == elements[1]
+        expect(locate_one(selector)).to eq elements[1]
       end
 
       it "handles data-* attributes with regexp" do
@@ -248,7 +259,7 @@ describe Watir::ElementLocator do
           :data_automation_id => /bar/
         }
 
-        locate_one(selector).should == elements[1]
+        expect(locate_one(selector)).to eq elements[1]
       end
 
       it "handles :label => /regexp/ selector" do
@@ -266,12 +277,12 @@ describe Watir::ElementLocator do
           expect_all(:xpath, ".//div[@id='baz']").ordered.and_return(div_elements)
         end
 
-        locate_one(:tag_name => "div", :label => /oob/).should == div_elements.first
+        expect(locate_one(:tag_name => "div", :label => /oob/)).to eq div_elements.first
       end
 
       it "returns nil when no label matching the regexp is found" do
         expect_all(:tag_name, "label").and_return([])
-        locate_one(:tag_name => "div", :label => /foo/).should be_nil
+        expect(locate_one(:tag_name => "div", :label => /foo/)).to be_nil
       end
 
     end
@@ -295,7 +306,7 @@ describe Watir::ElementLocator do
         :index    => 1
       }
 
-      locate_one(selector).should == elements[1]
+      expect(locate_one(selector)).to eq elements[1]
     end
 
     it "returns nil if found element didn't match the selector tag_name" do
@@ -306,29 +317,26 @@ describe Watir::ElementLocator do
         :xpath    => "//div"
       }
 
-      locate_one(selector, Watir::Input.attributes).should be_nil
+      expect(locate_one(selector, Watir::Input.attributes)).to be_nil
     end
 
     describe "errors" do
       it "raises a TypeError if :index is not a Fixnum" do
-        lambda {
-          locate_one(:tag_name => "div", :index => "bar")
-        }.should raise_error(TypeError, %[expected Fixnum, got "bar":String])
+        expect { locate_one(:tag_name => "div", :index => "bar") }.to \
+        raise_error(TypeError, %[expected Fixnum, got "bar":String])
       end
 
       it "raises a TypeError if selector value is not a String or Regexp" do
-        lambda {
-          locate_one(:tag_name => 123)
-        }.should raise_error(TypeError, %[expected one of [String, Regexp], got 123:Fixnum])
+        expect { locate_one(:tag_name => 123) }.to \
+        raise_error(TypeError, %[expected one of [String, Regexp], got 123:Fixnum])
       end
 
       it "raises a MissingWayOfFindingObjectException if the attribute is not valid" do
         bad_selector = {:tag_name => "input", :href => "foo"}
         valid_attributes = Watir::Input.attributes
 
-        lambda {
-          locate_one(bad_selector, valid_attributes)
-        }.should raise_error(MissingWayOfFindingObjectException, "invalid attribute: :href")
+        expect { locate_one(bad_selector, valid_attributes) }.to \
+        raise_error(MissingWayOfFindingObjectException, "invalid attribute: :href")
       end
     end
   end
@@ -383,8 +391,7 @@ describe Watir::ElementLocator do
           expect_all(:xpath, ".//div").and_return(elements)
         end
 
-
-        locate_all(:tag_name => "div", :class => /oob/).should == elements.last(3)
+        expect(locate_all(:tag_name => "div", :class => /oob/)).to eq elements.last(3)
       end
 
       it "handles mix of string and regexp attributes" do
@@ -406,15 +413,14 @@ describe Watir::ElementLocator do
           :title    => /baz/
         }
 
-        locate_all(selector).should == elements.last(2)
+        expect(locate_all(selector)).to eq elements.last(2)
       end
     end
 
     describe "errors" do
       it "raises ArgumentError if :index is given" do
-        lambda {
-          locate_all(:tag_name => "div", :index => 1)
-        }.should raise_error(ArgumentError, "can't locate all elements by :index")
+        expect { locate_all(:tag_name => "div", :index => 1) }.to \
+        raise_error(ArgumentError, "can't locate all elements by :index")
       end
     end
   end

data/spec/element_spec.rb

@@ -8,25 +8,25 @@ describe Watir::Element do
     end
 
     it 'returns true if the element exists and is visible' do
-      browser.div(:id, 'foo').should be_present
+      expect(browser.div(:id, 'foo')).to be_present
     end
 
     it 'returns false if the element exists but is not visible' do
-      browser.div(:id, 'bar').should_not be_present
+      expect(browser.div(:id, 'bar')).to_not be_present
     end
 
     it 'returns false if the element does not exist' do
-      browser.div(:id, 'should-not-exist').should_not be_present
+      expect(browser.div(:id, 'should-not-exist')).to_not be_present
     end
   end
 
   describe "#reset!" do
     it "successfully relocates collection elements after a reset!" do
       element = browser.divs(:id, 'foo').to_a.first
-      element.should_not be_nil
+      expect(element).to_not be_nil
 
       element.send :reset!
-      element.should exist
+      expect(element).to exist
     end
   end
 
@@ -37,9 +37,9 @@ describe Watir::Element do
       button  = browser.button(:id => "remove-button")
       element = browser.div(:id => "text")
 
-      element.should exist
+      expect(element).to exist
       button.click
-      element.should_not exist
+      expect(element).to_not exist
     end
   end
 
@@ -52,9 +52,9 @@ describe Watir::Element do
         browser.goto WatirSpec.url_for('hover.html', :needs_server => true)
         link = browser.a
 
-        link.style("font-size").should == "10px"
+        expect(link.style("font-size")).to eq "10px"
         link.hover
-        link.style("font-size").should == "20px"
+        expect(link.style("font-size")).to eq "20px"
       end
     end
   end

data/spec/implementation.rb

@@ -107,7 +107,7 @@ class ImplementationConfig
 
   def chrome_args
     opts = {
-      :switches      => ["--disable-translate"],
+      :args          => ["--disable-translate"],
       :native_events => native_events?
     }
 
@@ -123,11 +123,15 @@ class ImplementationConfig
       Selenium::WebDriver::Chrome.path = path
     end
 
+    if ENV['TRAVIS']
+      opts[:args] << "--no-sandbox" # https://github.com/travis-ci/travis-ci/issues/938
+    end
+
     [:chrome, opts]
   end
 
   def remote_args
-    [:remote, {:url => ENV["WATIR_WEBDRIVER_REMOTE_URL"] || "http://127.0.0.1:8080"}]    
+    [:remote, {:url => ENV["WATIR_WEBDRIVER_REMOTE_URL"] || "http://127.0.0.1:8080"}]
   end
 
   def add_html_routes

data/spec/input_spec.rb

@@ -9,12 +9,12 @@ describe Watir::Input do
   describe "#to_subtype" do
     it "returns a CheckBox instance" do
       e = browser.input(:xpath => "//input[@type='checkbox']").to_subtype
-      e.should be_kind_of(Watir::CheckBox)
+      expect(e).to be_kind_of(Watir::CheckBox)
     end
 
     it "returns a Radio instance" do
       e = browser.input(:xpath => "//input[@type='radio']").to_subtype
-      e.should be_kind_of(Watir::Radio)
+      expect(e).to be_kind_of(Watir::Radio)
     end
 
     it "returns a Button instance" do
@@ -23,17 +23,23 @@ describe Watir::Input do
         browser.input(:xpath => "//input[@type='submit']").to_subtype
       ]
 
-      es.all? { |e| e.should be_kind_of(Watir::Button) }
+      es.all? { |e| expect(e).to be_kind_of(Watir::Button) }
     end
 
     it "returns a TextField instance" do
       e = browser.input(:xpath => "//input[@type='text']").to_subtype
-      e.should be_kind_of(Watir::TextField)
+      expect(e).to be_kind_of(Watir::TextField)
     end
 
     it "returns a TextField instance" do
       e = browser.input(:xpath => "//input[@type='file']").to_subtype
-      e.should be_kind_of(Watir::FileField)
+      expect(e).to be_kind_of(Watir::FileField)
+    end
+  end
+
+  describe "#type" do
+    it "returns an email type" do
+      expect(browser.input(:name => "html5_email").type).to eq 'email'
     end
   end
 end