page-object 1.0.2 → 1.0.3

data/spec/page-object/elements/option_spec.rb

@@ -5,7 +5,7 @@ describe PageObject::Elements::Option do
 
   describe "interface" do
     it "should register as tag_name :option" do
-      ::PageObject::Elements.element_class_for(:option).should == ::PageObject::Elements::Option
+      expect(::PageObject::Elements.element_class_for(:option)).to eql ::PageObject::Elements::Option
     end
   end
 end

data/spec/page-object/elements/ordered_list_spec.rb

@@ -8,14 +8,14 @@ describe PageObject::Elements::OrderedList do
     it "should map watir types to same" do
       [:class, :id, :index, :xpath].each do |t|
         identifier = ol.watir_identifier_for t => 'value'
-        identifier.keys.first.should == t
+        expect(identifier.keys.first).to eql t
       end
     end
 
     it "should map selenium types to same" do
       [:class, :id, :index, :name, :xpath].each do |t|
         key, value = ol.selenium_identifier_for t => 'value'
-        key.should == t
+        expect(key).to eql t
       end
     end
   end
@@ -24,70 +24,70 @@ describe PageObject::Elements::OrderedList do
     let(:ol_element) { double('ol_element') }
 
     it "should register as tag_name :ol" do
-      ::PageObject::Elements.element_class_for(:ol).should == ::PageObject::Elements::OrderedList
+      expect(::PageObject::Elements.element_class_for(:ol)).to eql ::PageObject::Elements::OrderedList
     end
 
     context "for watir" do
       it "should return a list item when indexed" do
         ol = PageObject::Elements::OrderedList.new(ol_element, :platform => :watir_webdriver)
-        ol_element.stub(:ols).and_return([ol_element])
-        ol_element.stub(:find_elements).and_return(ol_element)
-        ol_element.stub(:map).and_return([ol_element])
-        ol_element.stub(:parent).and_return(ol_element)
-        ol_element.stub(:element).and_return(ol_element)
-        ol_element.stub(:==).and_return(true)
+        allow(ol_element).to receive(:ols).and_return([ol_element])
+        allow(ol_element).to receive(:find_elements).and_return(ol_element)
+        allow(ol_element).to receive(:map).and_return([ol_element])
+        allow(ol_element).to receive(:parent).and_return(ol_element)
+        allow(ol_element).to receive(:element).and_return(ol_element)
+        allow(ol_element).to receive(:==).and_return(true)
         ol[1]
       end
 
       it "should know how many list items it contains" do
         ol = PageObject::Elements::OrderedList.new(ol_element, :platform => :watir_webdriver)
-        ol_element.stub(:ols).and_return([ol_element])
-        ol_element.stub(:find_elements).and_return(ol_element)
-        ol_element.stub(:map).and_return([ol_element])
-        ol_element.stub(:parent).and_return(ol_element)
-        ol_element.stub(:element).and_return(ol_element)
-        ol_element.stub(:==).and_return(true)
-        ol.items.should == 1
+        allow(ol_element).to receive(:ols).and_return([ol_element])
+        allow(ol_element).to receive(:find_elements).and_return(ol_element)
+        allow(ol_element).to receive(:map).and_return([ol_element])
+        allow(ol_element).to receive(:parent).and_return(ol_element)
+        allow(ol_element).to receive(:element).and_return(ol_element)
+        allow(ol_element).to receive(:==).and_return(true)
+        expect(ol.items).to eql 1
       end
 
       it "should iterate over the list items" do
         ol = PageObject::Elements::OrderedList.new(ol_element, :platform => :watir_webdriver)
-        ol.should_receive(:items).and_return(5)
-        ol.stub(:[])
+        expect(ol).to receive(:items).and_return(5)
+        allow(ol).to receive(:[])
         count = 0
         ol.each { |item| count += 1 }
-        count.should == 5
+        expect(count).to eql 5
       end
     end
 
     context "for selenium" do
       it "should return a list item when indexed" do
         ol = PageObject::Elements::OrderedList.new(ol_element, :platform => :selenium_webdriver)
-        ol_element.should_receive(:find_elements).and_return(ol_element)
-        ol_element.should_receive(:map).and_return([ol_element])
-        ol_element.should_receive(:parent).and_return(ol_element)
-        ol_element.should_receive(:element).and_return(ol_element)
-        ol_element.should_receive(:==).and_return(true)
+        expect(ol_element).to receive(:find_elements).and_return(ol_element)
+        expect(ol_element).to receive(:map).and_return([ol_element])
+        expect(ol_element).to receive(:parent).and_return(ol_element)
+        expect(ol_element).to receive(:element).and_return(ol_element)
+        expect(ol_element).to receive(:==).and_return(true)
         ol[1]
       end
 
       it "should know how many list items it contains" do
         ol = PageObject::Elements::OrderedList.new(ol_element, :platform => :selenium_webdriver)
-        ol_element.should_receive(:find_elements).and_return(ol_element)
-        ol_element.should_receive(:map).and_return([ol_element])
-        ol_element.should_receive(:parent).and_return(ol_element)
-        ol_element.should_receive(:element).and_return(ol_element)
-        ol_element.should_receive(:==).and_return(true)
-        ol.items.should == 1
+        expect(ol_element).to receive(:find_elements).and_return(ol_element)
+        expect(ol_element).to receive(:map).and_return([ol_element])
+        expect(ol_element).to receive(:parent).and_return(ol_element)
+        expect(ol_element).to receive(:element).and_return(ol_element)
+        expect(ol_element).to receive(:==).and_return(true)
+        expect(ol.items).to eql 1
       end
 
       it "should iterate over the list items" do
         ol = PageObject::Elements::OrderedList.new(ol_element, :platform => :selenium_webdriver)
-        ol.should_receive(:items).and_return(5)
-        ol.stub(:[])
+        expect(ol).to receive(:items).and_return(5)
+        allow(ol).to receive(:[])
         count = 0
         ol.each { |item| count += 1 }
-        count.should == 5
+        expect(count).to eql 5
       end
     end
   end

data/spec/page-object/elements/paragraph_spec.rb

@@ -8,21 +8,20 @@ describe PageObject::Elements::Paragraph do
     it "should map watir types to same" do
       [:class, :id, :index, :name, :xpath].each do |t|
         identifier = paragraph.watir_identifier_for t => 'value'
-        identifier.keys.first.should == t
+        expect(identifier.keys.first).to eql t
       end
     end
     it "should map selenium types to same" do
       [:class, :id, :name, :xpath, :index].each do |t|
         key, value = paragraph.selenium_identifier_for t => 'value'
-        key.should == t
+        expect(key).to eql t
       end
     end
   end
   
   describe "interface" do
-
     it "should register with type :checkbox" do
-      ::PageObject::Elements.element_class_for(:p).should == ::PageObject::Elements::Paragraph
+      expect(::PageObject::Elements.element_class_for(:p)).to eql ::PageObject::Elements::Paragraph
     end
   end
 end

data/spec/page-object/elements/select_list_spec.rb

@@ -8,14 +8,14 @@ describe PageObject::Elements::SelectList do
     it "should map watir types to same" do
       [:class, :id, :index, :name, :text, :value, :xpath].each do |t|
         identifier = selectlist.watir_identifier_for t => 'value'
-        identifier.keys.first.should == t
+        expect(identifier.keys.first).to eql t
       end
     end
 
     it "should map selenium types to same" do
       [:class, :id, :name, :xpath, :index].each do |t|
         key, value = selectlist.selenium_identifier_for t => 'value'
-        key.should == t
+        expect(key).to eql t
       end
     end
   end
@@ -25,53 +25,53 @@ describe PageObject::Elements::SelectList do
     let(:opts) { [sel_list, sel_list] }
 
     before(:each) do
-      sel_list.stub(:find_elements).and_return(sel_list)
-      sel_list.stub(:each)
-      sel_list.stub(:wd).and_return(sel_list)
-      sel_list.stub(:map).and_return(opts)
-      sel_list.stub(:any?)
-      sel_list.stub(:include?)
-      sel_list.stub(:select).and_return(opts)
-      sel_list.stub(:text).and_return('blah')
+      allow(sel_list).to receive(:find_elements).and_return(sel_list)
+      allow(sel_list).to receive(:each)
+      allow(sel_list).to receive(:wd).and_return(sel_list)
+      allow(sel_list).to receive(:map).and_return(opts)
+      allow(sel_list).to receive(:any?)
+      allow(sel_list).to receive(:include?)
+      allow(sel_list).to receive(:select).and_return(opts)
+      allow(sel_list).to receive(:text).and_return('blah')
     end
 
     it "should register with tag_name :select" do
-      ::PageObject::Elements.element_class_for(:select).should == ::PageObject::Elements::SelectList
+      expect(::PageObject::Elements.element_class_for(:select)).to eql ::PageObject::Elements::SelectList
     end
 
     context "for watir" do
       let(:watir_sel_list) { PageObject::Elements::SelectList.new(sel_list, :platform => :watir_webdriver) }
 
       it "should return an option when indexed" do
-        sel_list.should_receive(:find_elements).with(:xpath, ".//child::option").and_return(opts)
-        watir_sel_list[0].should be_instance_of PageObject::Elements::Option
+        expect(sel_list).to receive(:find_elements).with(:xpath, ".//child::option").and_return(opts)
+        expect(watir_sel_list[0]).to be_instance_of PageObject::Elements::Option
       end
 
       it "should return an array of options" do
-        sel_list.should_receive(:find_elements).with(:xpath, ".//child::option").and_return(opts)
-        watir_sel_list.options.size.should == 2
+        expect(sel_list).to receive(:find_elements).with(:xpath, ".//child::option").and_return(opts)
+        expect(watir_sel_list.options.size).to eql 2
       end
 
       it "should return an array of selected options" do
-        sel_list.stub(:selected_options).and_return(opts)
-        sel_list.stub(:text).and_return(sel_list)
-        watir_sel_list.selected_options.should == opts
+        allow(sel_list).to receive(:selected_options).and_return(opts)
+        allow(sel_list).to receive(:text).and_return(sel_list)
+        expect(watir_sel_list.selected_options).to eql opts
       end
 
       it "should know if it includes some value" do
-        sel_list.stub(:include?).with('blah').and_return(true)
+        allow(sel_list).to receive(:include?).with('blah').and_return(true)
         watir_sel_list.include?('blah')
       end
 
       it "should know if an option is selected" do
-        sel_list.stub(:selected?).with('blah').and_return(true)
+        allow(sel_list).to receive(:selected?).with('blah').and_return(true)
         watir_sel_list.selected?('blah')
       end
 
       it "should be able to get the value for the selected options" do
-        sel_list.stub(:selected_options).and_return(opts)
-        sel_list.stub(:value).and_return(sel_list)
-        watir_sel_list.selected_values.should == opts
+        allow(sel_list).to receive(:selected_options).and_return(opts)
+        allow(sel_list).to receive(:value).and_return(sel_list)
+        expect(watir_sel_list.selected_values).to eql opts
       end
     end
 
@@ -79,61 +79,61 @@ describe PageObject::Elements::SelectList do
       let(:selenium_sel_list) { PageObject::Elements::SelectList.new(sel_list, :platform => :selenium_webdriver) }
 
       it "should return an option when indexed" do
-        sel_list.should_receive(:find_elements).with(:xpath, ".//child::option").and_return(opts)
-        selenium_sel_list[1].should be_instance_of PageObject::Elements::Option
+        expect(sel_list).to receive(:find_elements).with(:xpath, ".//child::option").and_return(opts)
+        expect(selenium_sel_list[1]).to be_instance_of PageObject::Elements::Option
       end
 
       it "should return an array of options" do
-        sel_list.should_receive(:find_elements).with(:xpath, ".//child::option").and_return(opts)
-        selenium_sel_list.options.size.should == 2
+        expect(sel_list).to receive(:find_elements).with(:xpath, ".//child::option").and_return(opts)
+        expect(selenium_sel_list.options.size).to eql 2
       end
 
       it "should select an element" do
         option = double('option')
-        sel_list.should_receive(:find_elements).with(:xpath, ".//child::option").and_return([option])
-        option.should_receive(:text).and_return('something')
-        option.should_receive(:click)
+        expect(sel_list).to receive(:find_elements).with(:xpath, ".//child::option").and_return([option])
+        expect(option).to receive(:text).and_return('something')
+        expect(option).to receive(:click)
         selenium_sel_list.select 'something'
       end
 
       it "should return an array of selected options" do
-        sel_list.should_receive(:find_elements).with(:xpath, ".//child::option").and_return(opts)
-        opts[0].should_receive(:selected?).and_return(true)
-        opts[0].should_receive(:text).and_return('test1')
-        opts[1].should_receive(:selected?).and_return(false)
+        expect(sel_list).to receive(:find_elements).with(:xpath, ".//child::option").and_return(opts)
+        expect(opts[0]).to receive(:selected?).and_return(true)
+        expect(opts[0]).to receive(:text).and_return('test1')
+        expect(opts[1]).to receive(:selected?).and_return(false)
         selected = selenium_sel_list.selected_options
-        selected.size.should == 1
-        selected[0].should == 'test1'
+        expect(selected.size).to eql 1
+        expect(selected[0]).to eql 'test1'
       end
 
       it "should return an array of selected options" do
-        sel_list.should_receive(:find_elements).with(:xpath, ".//child::option").and_return(opts)
-        opts[0].should_receive(:selected?).and_return(true)
-        opts[0].should_receive(:attribute).and_return('test1')
-        opts[1].should_receive(:selected?).and_return(false)
+        expect(sel_list).to receive(:find_elements).with(:xpath, ".//child::option").and_return(opts)
+        expect(opts[0]).to receive(:selected?).and_return(true)
+        expect(opts[0]).to receive(:attribute).and_return('test1')
+        expect(opts[1]).to receive(:selected?).and_return(false)
         selected = selenium_sel_list.selected_values
-        selected.size.should == 1
-        selected[0].should == 'test1'
+        expect(selected.size).to eql 1
+        expect(selected[0]).to eql 'test1'
       end
 
       it "should know if it includes some value" do
-        sel_list.should_receive(:find_elements).and_return(opts)
-        opts[0].should_receive(:text).and_return('blah')
-        selenium_sel_list.should include 'blah'
+        expect(sel_list).to receive(:find_elements).and_return(opts)
+        expect(opts[0]).to receive(:text).and_return('blah')
+        expect(selenium_sel_list).to include 'blah'
       end
 
       it "should know if an option is selected" do
-        sel_list.should_receive(:find_elements).and_return(opts)
-        opts[0].should_receive(:selected?).twice.and_return(true)
-        opts[0].should_receive(:text).and_return('blah')
-        selenium_sel_list.selected?('blah').should be true
+        expect(sel_list).to receive(:find_elements).and_return(opts)
+        expect(opts[0]).to receive(:selected?).twice.and_return(true)
+        expect(opts[0]).to receive(:text).and_return('blah')
+        expect(selenium_sel_list.selected?('blah')).to be true
       end
 
       it "should be able to clear selected options" do
-        sel_list.should_receive(:find_elements).and_return(opts)
+        expect(sel_list).to receive(:find_elements).and_return(opts)
         opts.each do |opt|
-          opt.should_receive(:selected?).and_return(true)
-          opt.should_receive(:click)
+          expect(opt).to receive(:selected?).and_return(true)
+          expect(opt).to receive(:click)
         end
         selenium_sel_list.clear
       end

data/spec/page-object/elements/selenium/radio_button_spec.rb

@@ -8,13 +8,13 @@ describe PageObject::Elements::RadioButton do
     it "should map watir types to same" do
       [:class, :id, :index, :name, :value, :xpath].each do |t|
         identifier = radiobutton.watir_identifier_for t => 'value'
-        identifier.keys.first.should == t
+        expect(identifier.keys.first).to eql t
       end
     end
     it "should map selenium types to same" do
       [:class, :id, :name, :xpath, :value, :index].each do |t|
         key, value = radiobutton.selenium_identifier_for t => 'value'
-        key.should == t
+        expect(key).to eql t
       end
     end
   end
@@ -22,7 +22,7 @@ describe PageObject::Elements::RadioButton do
   describe "interface" do
 
     it "should register as type :radio" do
-      ::PageObject::Elements.element_class_for(:input, :radio).should == ::PageObject::Elements::RadioButton
+      expect(::PageObject::Elements.element_class_for(:input, :radio)).to eql ::PageObject::Elements::RadioButton
     end
     
     context "for selenium" do
@@ -30,20 +30,14 @@ describe PageObject::Elements::RadioButton do
       let(:radio_button) { PageObject::Elements::RadioButton.new(selenium_rb, :platform => :selenium_webdriver) }
 
       it "should select" do
-        selenium_rb.should_receive(:click)
-        selenium_rb.should_receive(:selected?).and_return(false)
+        expect(selenium_rb).to receive(:click)
+        expect(selenium_rb).to receive(:selected?).and_return(false)
         radio_button.select
       end
       
-      it "should clear" do
-        selenium_rb.should_receive(:click)
-        selenium_rb.should_receive(:selected?).and_return(true)
-        radio_button.clear
-      end
-      
       it "should know if it is selected" do
-        selenium_rb.should_receive(:selected?).and_return(true)
-        radio_button.should be_selected
+        expect(selenium_rb).to receive(:selected?).and_return(true)
+        expect(radio_button).to be_selected
       end
     end
   end

data/spec/page-object/elements/selenium/text_field_spec.rb

@@ -9,14 +9,14 @@ describe PageObject::Elements::TextField do
     it "should map watir types to same" do
       [:class, :id, :index, :name, :title, :xpath, :text, :label].each do |t|
         identifier = textfield.watir_identifier_for t => 'value'
-        identifier.keys.first.should == t
+        expect(identifier.keys.first).to eql t
       end
     end
 
     it "should map selenium types to same" do
       [:class, :id, :name, :title, :xpath, :index, :text, :label].each do |t|
         key, value = textfield.selenium_identifier_for t => 'value'
-        key.should == t
+        expect(key).to eql t
       end
     end
   end
@@ -26,22 +26,22 @@ describe PageObject::Elements::TextField do
     let(:selenium_text_field) { PageObject::Elements::TextField.new(text_field_element, :platform => :selenium_webdriver) }
 
     it "should register with type :text" do
-      ::PageObject::Elements.element_class_for(:input, :text).should == ::PageObject::Elements::TextField
+      expect(::PageObject::Elements.element_class_for(:input, :text)).to eql ::PageObject::Elements::TextField
     end
 
     it "should register with type :password" do
-      ::PageObject::Elements.element_class_for(:input, :password).should == ::PageObject::Elements::TextField
+      expect(::PageObject::Elements.element_class_for(:input, :password)).to eql ::PageObject::Elements::TextField
     end
 
     it "should append text" do
-      text_field_element.should_receive(:send_keys).with('abc')
+      expect(text_field_element).to receive(:send_keys).with('abc')
       selenium_text_field.append('abc')
     end
     
     context "for selenium" do
       it "should set its' value" do
-        text_field_element.should_receive(:clear)
-        text_field_element.should_receive(:send_keys).with('Joseph')
+        expect(text_field_element).to receive(:clear)
+        expect(text_field_element).to receive(:send_keys).with('Joseph')
         selenium_text_field.value = 'Joseph'
       end
     end

data/spec/page-object/elements/selenium_element_spec.rb

@@ -9,164 +9,164 @@ describe "Element for Selenium" do
   end
 
   it "should know when it is visible" do
-    @selenium_driver.should_receive(:displayed?).and_return(true)
-    @selenium_element.visible?.should == true
+    expect(@selenium_driver).to receive(:displayed?).and_return(true)
+    expect(@selenium_element.visible?).to be true
   end
 
   it "should know when it is not visible" do
-    @selenium_driver.should_receive(:displayed?).and_return(false)
-    @selenium_element.visible?.should == false
+    expect(@selenium_driver).to receive(:displayed?).and_return(false)
+    expect(@selenium_element.visible?).to eql false
   end
 
   it "should know when it exists" do
-    @selenium_driver.should_receive(:nil?).and_return(false)
-    @selenium_element.exists?.should == true
+    expect(@selenium_driver).to receive(:nil?).and_return(false)
+    expect(@selenium_element.exists?).to eql true
   end
 
   it "should know when it does not exist" do
     @selenium_element = ::PageObject::Elements::Element.new(nil, :platform => :selenium_webdriver)
-    @selenium_element.exists?.should == false
+    expect(@selenium_element.exists?).to eql false
   end
 
   it "should flash an element" do
     bridge = double('bridge')
-    @selenium_driver.should_receive(:attribute).and_return('blue')
-    @selenium_driver.should_receive(:instance_variable_get).and_return(bridge)
-    bridge.should_receive(:executeScript).exactly(10).times
+    expect(@selenium_driver).to receive(:attribute).and_return('blue')
+    expect(@selenium_driver).to receive(:instance_variable_get).and_return(bridge)
+    expect(bridge).to receive(:executeScript).exactly(10).times
     @selenium_element.flash
   end
 
   it "should be able to return the text contained in the element" do
-    @selenium_driver.should_receive(:text).and_return("my text")
-    @selenium_element.text.should == "my text"
+    expect(@selenium_driver).to receive(:text).and_return("my text")
+    expect(@selenium_element.text).to eql "my text"
   end
 
   it "should know when it is equal to another" do
-    @selenium_driver.should_receive(:==).and_return(true)
-    @selenium_element.should == @selenium_element
+    expect(@selenium_driver).to receive(:==).and_return(true)
+    expect(@selenium_element).to eq @selenium_element
   end
 
   it "should return its tag name" do
-    @selenium_driver.should_receive(:tag_name).and_return("h1")
-    @selenium_element.tag_name.should == "h1"
+    expect(@selenium_driver).to receive(:tag_name).and_return("h1")
+    expect(@selenium_element.tag_name).to eql "h1"
   end
 
   it "should know its value" do
-    @selenium_driver.should_receive(:attribute).with('value').and_return("value")
-    @selenium_element.value.should == "value"
+    expect(@selenium_driver).to receive(:attribute).with('value').and_return("value")
+    expect(@selenium_element.value).to eql "value"
   end
 
   it "should know how to retrieve the value of an attribute" do
-    @selenium_driver.should_receive(:attribute).and_return(true)
-    @selenium_element.attribute('readonly').should be true
+    expect(@selenium_driver).to receive(:attribute).and_return(true)
+    expect(@selenium_element.attribute('readonly')).to be true
   end
 
   it "should be clickable" do
-    @selenium_driver.should_receive(:click)
+    expect(@selenium_driver).to receive(:click)
     @selenium_element.click
   end
 
   it "should be double clickable" do
-    Selenium::WebDriver::Mouse.should_receive(:new).and_return(@selenium_driver)
-    @selenium_driver.should_receive(:double_click)
+    expect(Selenium::WebDriver::Mouse).to receive(:new).and_return(@selenium_driver)
+    expect(@selenium_driver).to receive(:double_click)
     @selenium_element.double_click
   end
   
   it "should be right clickable" do
-    @selenium_driver.should_receive(:context_click)
+    expect(@selenium_driver).to receive(:context_click)
     @selenium_element.right_click
   end
 
   it "should be able to block until it is present" do
     wait = double('wait')
-    ::Selenium::WebDriver::Wait.should_receive(:new).and_return(wait)
-    wait.should_receive(:until)
+    expect(::Selenium::WebDriver::Wait).to receive(:new).and_return(wait)
+    expect(wait).to receive(:until)
     @selenium_element.when_present(10)
   end
   
   it "should return the element when it is present" do
     wait = double('wait')
-    ::Selenium::WebDriver::Wait.should_receive(:new).and_return(wait)
-    wait.should_receive(:until)
+    expect(::Selenium::WebDriver::Wait).to receive(:new).and_return(wait)
+    expect(wait).to receive(:until)
     element = @selenium_element.when_present(10)
-    element.should === @selenium_element
+    expect(element).to equal @selenium_element
   end
 
   it "should return when an element is not present" do
     wait = double('wait')
-    ::Selenium::WebDriver::Wait.should_receive(:new).and_return(wait)
-    wait.should_receive(:until)
+    expect(::Selenium::WebDriver::Wait).to receive(:new).and_return(wait)
+    expect(wait).to receive(:until)
     @selenium_element.when_not_present
   end
 
   it "should be able to block until it is visible" do
     wait = double('wait')
-    ::Selenium::WebDriver::Wait.should_receive(:new).and_return(wait)
-    wait.should_receive(:until)
+    expect(::Selenium::WebDriver::Wait).to receive(:new).and_return(wait)
+    expect(wait).to receive(:until)
     @selenium_element.when_visible(10)
   end
   
   it "should return the element when it is visible" do
     wait = double('wait')
-    ::Selenium::WebDriver::Wait.should_receive(:new).and_return(wait)
-    wait.should_receive(:until)
+    expect(::Selenium::WebDriver::Wait).to receive(:new).and_return(wait)
+    expect(wait).to receive(:until)
     element = @selenium_element.when_visible(10)
-    element.should === @selenium_element
+    expect(element).to equal @selenium_element
   end
 
   it "should be able to block until it is not visible" do
     wait = double('wait')
-    ::Selenium::WebDriver::Wait.should_receive(:new).and_return(wait)
-    wait.should_receive(:until)
+    expect(::Selenium::WebDriver::Wait).to receive(:new).and_return(wait)
+    expect(wait).to receive(:until)
     @selenium_element.when_not_visible(10)
   end
 
   it "should return the element when it is not visible" do
     wait = double('wait')
-    ::Selenium::WebDriver::Wait.should_receive(:new).and_return(wait)
-    wait.should_receive(:until)
+    expect(::Selenium::WebDriver::Wait).to receive(:new).and_return(wait)
+    expect(wait).to receive(:until)
     element = @selenium_element.when_not_visible(10)
-    element.should === @selenium_element
+    expect(element).to equal @selenium_element
   end
 
   it "should be able to block until a user define event fires true" do
     wait = double('wait')
-    ::Selenium::WebDriver::Wait.should_receive(:new).and_return(wait)
-    wait.should_receive(:until)
+    expect(::Selenium::WebDriver::Wait).to receive(:new).and_return(wait)
+    expect(wait).to receive(:until)
     @selenium_element.wait_until(10, "Element blah") {}
   end
 
   it "should send keys to the element" do
-    @selenium_driver.should_receive(:send_keys).with([:control, 'a'])
+    expect(@selenium_driver).to receive(:send_keys).with([:control, 'a'])
     @selenium_element.send_keys([:control, 'a'])
   end
   
   it "should clear its' contents" do
-    @selenium_driver.should_receive(:clear)
+    expect(@selenium_driver).to receive(:clear)
     @selenium_element.clear
   end
 
   it "should fire an event" do
-    @selenium_driver.should_receive(:instance_variable_get).with(:@bridge).and_return(@selenium_driver)
-    @selenium_driver.should_receive(:executeScript)
+    expect(@selenium_driver).to receive(:instance_variable_get).with(:@bridge).and_return(@selenium_driver)
+    expect(@selenium_driver).to receive(:executeScript)
     @selenium_element.fire_event('onfocus')
   end
 
   it "should find the parent element" do
-    @selenium_driver.should_receive(:instance_variable_get).with(:@bridge).and_return(@selenium_driver)
-    @selenium_driver.should_receive(:executeScript).and_return(@selenium_driver)
-    @selenium_driver.should_receive(:tag_name).twice.and_return(:div)
+    expect(@selenium_driver).to receive(:instance_variable_get).with(:@bridge).and_return(@selenium_driver)
+    expect(@selenium_driver).to receive(:executeScript).and_return(@selenium_driver)
+    expect(@selenium_driver).to receive(:tag_name).twice.and_return(:div)
     @selenium_element.parent
   end
 
   it "should set the focus" do
-    @selenium_driver.should_receive(:instance_variable_get).and_return(@selenium_driver)
-    @selenium_driver.should_receive(:executeScript)
+    expect(@selenium_driver).to receive(:instance_variable_get).and_return(@selenium_driver)
+    expect(@selenium_driver).to receive(:executeScript)
     @selenium_element.focus
   end
 
   it "should scroll into view" do
-    @selenium_driver.should_receive(:location_once_scrolled_into_view)
+    expect(@selenium_driver).to receive(:location_once_scrolled_into_view)
     @selenium_element.scroll_into_view
   end
 end