page-object 1.0.2 → 1.0.3

data/spec/page-object/platforms/selenium_webdriver_spec.rb

@@ -4,26 +4,26 @@ require 'spec_helper'
 describe PageObject::Platforms::SeleniumWebDriver do
 
   it "should be registered as an adapter" do
-    PageObject::Platforms.get[:selenium_webdriver].should be PageObject::Platforms::SeleniumWebDriver
-
+    expect(PageObject::Platforms.get[:selenium_webdriver]).to be PageObject::Platforms::SeleniumWebDriver
   end
+  
   describe 'create page object' do
     let(:browser) { double('browser') }
     let(:subject) { PageObject::Platforms::SeleniumWebDriver.create_page_object(browser) }
     
     it "should create a SeleniumPageObject" do
-      subject.should be_kind_of PageObject::Platforms::SeleniumWebDriver::PageObject
+      expect(subject).to be_kind_of PageObject::Platforms::SeleniumWebDriver::PageObject
     end
   end
   
   describe "is for?" do
     it "should be true when the browser is a selenium driver" do
       browser = mock_selenium_browser()
-      PageObject::Platforms::SeleniumWebDriver.is_for?(browser).should == true
+      expect(PageObject::Platforms::SeleniumWebDriver.is_for?(browser)).to eql true
     end
     
     it "should be false when the browser is anything else" do
-      PageObject::Platforms::SeleniumWebDriver.is_for?("asdf").should == false
+      expect(PageObject::Platforms::SeleniumWebDriver.is_for?("asdf")).to eql false
     end
   end
-end
+end

data/spec/page-object/platforms/watir_webdriver/watir_page_object_spec.rb

@@ -6,23 +6,23 @@ describe PageObject::Platforms::WatirWebDriver do
     let(:subject) { PageObject::Platforms::WatirWebDriver.create_page_object(browser) }
     
     it "should create a WatirPageObject" do
-      subject.should be_kind_of PageObject::Platforms::WatirWebDriver::PageObject
+      expect(subject).to be_kind_of PageObject::Platforms::WatirWebDriver::PageObject
     end
     
     it "should give the watir page object the browser" do
-      subject.browser.should be browser
+      expect(subject.browser).to be browser
     end
   end
   
   describe "is for?" do
     it "should be true when the browser is Watir::Browser" do
       browser = mock_watir_browser()
-      PageObject::Platforms::WatirWebDriver.is_for?(browser).should be true
+      expect(PageObject::Platforms::WatirWebDriver.is_for?(browser)).to be true
     end
     
     it "should be false at any other point" do
       browser = 'asdf'
-      PageObject::Platforms::WatirWebDriver.is_for?('asdf').should be false
+      expect(PageObject::Platforms::WatirWebDriver.is_for?('asdf')).to be false
     end
   end
 end

data/spec/page-object/platforms/watir_webdriver_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe PageObject::Platforms::WatirWebDriver do
   
   it "should be in the PageObjects Adapters list" do
-    PageObject::Platforms.get[:watir_webdriver].should be PageObject::Platforms::WatirWebDriver
+    expect(PageObject::Platforms.get[:watir_webdriver]).to be PageObject::Platforms::WatirWebDriver
   end
   
 end

data/spec/page-object/selenium_accessors_spec.rb

@@ -35,6 +35,7 @@ class SeleniumAccessorsTestPageObject
   canvas(:my_canvas, :id => 'canvas')
   audio(:acdc, :id => 'audio_id')
   video(:movie, :id => 'movie_id')
+  b(:bold, :id=>'bold')
 end
 
 class SeleniumBlockPageObject
@@ -129,6 +130,10 @@ class SeleniumBlockPageObject
   video :movie do |element|
     'video'
   end
+
+  b :bold do |element|
+    'b'
+  end
 end
 
 describe PageObject::Accessors do
@@ -137,117 +142,117 @@ describe PageObject::Accessors do
   let(:block_page_object) { SeleniumBlockPageObject.new(selenium_browser) }
   
   before(:each) do
-    selenium_browser.stub(:switch_to).and_return(selenium_browser)
-    selenium_browser.stub(:default_content)
+    allow(selenium_browser).to receive(:switch_to).and_return(selenium_browser)
+    allow(selenium_browser).to receive(:default_content)
   end
 
   describe "link accessors" do
     it "should select a link" do
-      selenium_browser.stub_chain(:find_element, :click)
+      allow(selenium_browser).to receive_messages(find_element: selenium_browser, click: selenium_browser)
       selenium_page_object.google_search
     end
 
     it "should return a link element" do
-      selenium_browser.should_receive(:find_element).and_return(selenium_browser)
+      expect(selenium_browser).to receive(:find_element).and_return(selenium_browser)
       element = selenium_page_object.google_search_element
-      element.should be_instance_of PageObject::Elements::Link
+      expect(element).to be_instance_of PageObject::Elements::Link
     end
   end
 
 
   describe "text_field accessors" do
     it "should get the text from the text field element" do
-      selenium_browser.should_receive(:find_element).and_return(selenium_browser)
-      selenium_browser.should_receive(:attribute).with('value').and_return('Katie')
-      selenium_page_object.first_name.should == 'Katie'
+      expect(selenium_browser).to receive(:find_element).and_return(selenium_browser)
+      expect(selenium_browser).to receive(:attribute).with('value').and_return('Katie')
+      expect(selenium_page_object.first_name).to eql 'Katie'
     end
 
     it "should set some text on a text field element" do
-      selenium_browser.should_receive(:find_element).twice.and_return(selenium_browser)
-      selenium_browser.should_receive(:clear)
-      selenium_browser.should_receive(:send_keys).with('Katie')
+      expect(selenium_browser).to receive(:find_element).twice.and_return(selenium_browser)
+      expect(selenium_browser).to receive(:clear)
+      expect(selenium_browser).to receive(:send_keys).with('Katie')
       selenium_page_object.first_name = 'Katie'
     end
 
     it "should retrieve a text field element" do
-      selenium_browser.should_receive(:find_element).and_return(selenium_browser)
+      expect(selenium_browser).to receive(:find_element).and_return(selenium_browser)
       element = selenium_page_object.first_name_element
-      element.should be_instance_of PageObject::Elements::TextField
+      expect(element).to be_instance_of PageObject::Elements::TextField
     end
   end
 
 
   describe "hidden field accessors" do
     it "should get the text from a hidden field" do
-      selenium_browser.should_receive(:find_element).and_return(selenium_browser)
-      selenium_browser.should_receive(:attribute).with('value').and_return("12345")
-      selenium_page_object.social_security_number.should == "12345"
+      expect(selenium_browser).to receive(:find_element).and_return(selenium_browser)
+      expect(selenium_browser).to receive(:attribute).with('value').and_return("12345")
+      expect(selenium_page_object.social_security_number).to eql "12345"
     end
 
     it "should retrieve a hidden field element" do
-      selenium_browser.should_receive(:find_element).and_return(selenium_browser)
+      expect(selenium_browser).to receive(:find_element).and_return(selenium_browser)
       element = selenium_page_object.social_security_number_element
-      element.should be_instance_of PageObject::Elements::HiddenField
+      expect(element).to be_instance_of PageObject::Elements::HiddenField
     end
   end
 
   describe "text area accessors" do
     it "should set some text on the text area" do
-      selenium_browser.should_receive(:find_element).and_return(selenium_browser)
-      selenium_browser.should_receive(:clear)
-      selenium_browser.should_receive(:send_keys).with("123 main street")
+      expect(selenium_browser).to receive(:find_element).and_return(selenium_browser)
+      expect(selenium_browser).to receive(:clear)
+      expect(selenium_browser).to receive(:send_keys).with("123 main street")
       selenium_page_object.address = "123 main street"
     end
 
     it "should get the text from the text area" do
-      selenium_browser.should_receive(:find_element).and_return(selenium_browser)
-      selenium_browser.should_receive(:attribute).with('value').and_return("123 main street")
-      selenium_page_object.address.should == "123 main street"
+      expect(selenium_browser).to receive(:find_element).and_return(selenium_browser)
+      expect(selenium_browser).to receive(:attribute).with('value').and_return("123 main street")
+      expect(selenium_page_object.address).to eql "123 main street"
     end
 
     it "should retrieve a text area element" do
-      selenium_browser.should_receive(:find_element).and_return(selenium_browser)
+      expect(selenium_browser).to receive(:find_element).and_return(selenium_browser)
       element = selenium_page_object.address_element
-      element.should be_instance_of PageObject::Elements::TextArea
+      expect(element).to be_instance_of PageObject::Elements::TextArea
     end
   end
 
   describe "select_list accessors" do
     it "should should get the current item from a select list" do
       selected = "OH"
-      selected.should_receive(:selected?).and_return(selected)
-      selected.should_receive(:text).and_return("OH")
-      selenium_browser.should_receive(:find_element).and_return(selenium_browser)
-      selenium_browser.should_receive(:find_elements).and_return([selected])
-      selenium_page_object.state.should == "OH"
+      expect(selected).to receive(:selected?).and_return(selected)
+      expect(selected).to receive(:text).and_return("OH")
+      expect(selenium_browser).to receive(:find_element).and_return(selenium_browser)
+      expect(selenium_browser).to receive(:find_elements).and_return([selected])
+      expect(selenium_page_object.state).to eql "OH"
     end
 
     it "should set the current item of a select list" do
       option = double('option')
-      selenium_browser.should_receive(:find_element).and_return(selenium_browser)
-      selenium_browser.should_receive(:find_elements).and_return([option])
-      option.should_receive(:text).and_return('OH')
-      option.should_receive(:click)
+      expect(selenium_browser).to receive(:find_element).and_return(selenium_browser)
+      expect(selenium_browser).to receive(:find_elements).and_return([option])
+      expect(option).to receive(:text).and_return('OH')
+      expect(option).to receive(:click)
       selenium_page_object.state = "OH"
     end
 
     it "should retrieve the select list element" do
-      selenium_browser.should_receive(:find_element).and_return(selenium_browser)
+      expect(selenium_browser).to receive(:find_element).and_return(selenium_browser)
       element = selenium_page_object.state_element
-      element.should be_instance_of PageObject::Elements::SelectList
+      expect(element).to be_instance_of PageObject::Elements::SelectList
     end
     
     it "should return list of selection options" do
       option1 = double('option')
       option2 = double('option')
-      option1.should_receive(:text).and_return("CA")
-      option2.should_receive(:text).and_return("OH")
+      expect(option1).to receive(:text).and_return("CA")
+      expect(option2).to receive(:text).and_return("OH")
 
       select_element = double("select")
-      select_element.should_receive(:options).twice.and_return([option1, option2])
-      selenium_page_object.should_receive(:state_element).and_return(select_element)
+      expect(select_element).to receive(:options).twice.and_return([option1, option2])
+      expect(selenium_page_object).to receive(:state_element).and_return(select_element)
       
-      selenium_page_object.state_options.should == ["CA","OH"]
+      expect(selenium_page_object.state_options).to eql ["CA","OH"]
     end
     
   end
@@ -255,317 +260,310 @@ describe PageObject::Accessors do
 
   describe "check_box accessors" do
     it "should check a check box element" do
-      selenium_browser.should_receive(:find_element).twice.and_return(selenium_browser)
-      selenium_browser.should_receive(:selected?).and_return(false)
-      selenium_browser.should_receive(:click)
+      expect(selenium_browser).to receive(:find_element).twice.and_return(selenium_browser)
+      expect(selenium_browser).to receive(:selected?).and_return(false)
+      expect(selenium_browser).to receive(:click)
       selenium_page_object.check_active
     end
 
     it "should clear a check box element" do
-      selenium_browser.should_receive(:find_element).twice.and_return(selenium_browser)
-      selenium_browser.should_receive(:selected?).and_return(true)
-      selenium_browser.should_receive(:click)
+      expect(selenium_browser).to receive(:find_element).twice.and_return(selenium_browser)
+      expect(selenium_browser).to receive(:selected?).and_return(true)
+      expect(selenium_browser).to receive(:click)
       selenium_page_object.uncheck_active
     end
 
     it "should know if a check box element is selected" do
-      selenium_browser.should_receive(:find_element).and_return(selenium_browser)
-      selenium_browser.should_receive(:selected?).and_return(true)
-      selenium_page_object.active_checked?.should be true
+      expect(selenium_browser).to receive(:find_element).and_return(selenium_browser)
+      expect(selenium_browser).to receive(:selected?).and_return(true)
+      expect(selenium_page_object.active_checked?).to be true
     end
 
     it "should retrieve a checkbox element" do
-      selenium_browser.should_receive(:find_element).and_return(selenium_browser)
+      expect(selenium_browser).to receive(:find_element).and_return(selenium_browser)
       element = selenium_page_object.active_element
-      element.should be_instance_of PageObject::Elements::CheckBox
+      expect(element).to be_instance_of PageObject::Elements::CheckBox
     end
   end
 
 
   describe "radio accessors" do
     it "should select a radio button" do
-      selenium_browser.should_receive(:find_element).twice.and_return(selenium_browser)
-      selenium_browser.should_receive(:selected?).and_return(false)
-      selenium_browser.should_receive(:click)
+      expect(selenium_browser).to receive(:find_element).twice.and_return(selenium_browser)
+      expect(selenium_browser).to receive(:selected?).and_return(false)
+      expect(selenium_browser).to receive(:click)
       selenium_page_object.select_first
     end
 
-    it "should clear a radio button" do
-      selenium_browser.should_receive(:find_element).twice.and_return(selenium_browser)
-      selenium_browser.should_receive(:selected?).and_return(true)
-      selenium_browser.should_receive(:click)
-      selenium_page_object.clear_first
-    end
-
     it "should determine if a radio is selected" do
-      selenium_browser.should_receive(:find_element).and_return(selenium_browser)
-      selenium_browser.should_receive(:selected?).and_return(true)
+      expect(selenium_browser).to receive(:find_element).and_return(selenium_browser)
+      expect(selenium_browser).to receive(:selected?).and_return(true)
       selenium_page_object.first_selected?
     end
 
     it "should retrieve a radio button element" do
-      selenium_browser.should_receive(:find_element).and_return(selenium_browser)
+      expect(selenium_browser).to receive(:find_element).and_return(selenium_browser)
       element = selenium_page_object.first_element
-      element.should be_instance_of PageObject::Elements::RadioButton
+      expect(element).to be_instance_of PageObject::Elements::RadioButton
     end
   end
 
   describe "button accessors" do
     it "should be able to click a button" do
-      selenium_browser.should_receive(:find_element).and_return(selenium_browser)
-      selenium_browser.should_receive(:click)
+      expect(selenium_browser).to receive(:find_element).and_return(selenium_browser)
+      expect(selenium_browser).to receive(:click)
       selenium_page_object.click_me
     end
 
     it "should retrieve a button element" do
-      selenium_browser.should_receive(:find_element).and_return(selenium_browser)
+      expect(selenium_browser).to receive(:find_element).and_return(selenium_browser)
       element = selenium_page_object.click_me_element
-      element.should be_instance_of PageObject::Elements::Button
+      expect(element).to be_instance_of PageObject::Elements::Button
     end
   end
 
   describe "div accessors" do
     it "should retrieve the text from a div" do
-      selenium_browser.should_receive(:find_element).and_return(selenium_browser)
-      selenium_browser.should_receive(:text).and_return("Message from div")
-      selenium_page_object.message.should == "Message from div"
+      expect(selenium_browser).to receive(:find_element).and_return(selenium_browser)
+      expect(selenium_browser).to receive(:text).and_return("Message from div")
+      expect(selenium_page_object.message).to eql "Message from div"
     end
 
     it "should retrieve the div element from the page" do
-      selenium_browser.should_receive(:find_element).and_return(selenium_browser)
+      expect(selenium_browser).to receive(:find_element).and_return(selenium_browser)
       element = selenium_page_object.message_element
-      element.should be_instance_of PageObject::Elements::Div
+      expect(element).to be_instance_of PageObject::Elements::Div
     end
   end
 
   describe "span accessors" do
     it "should retrieve the text from a span" do
-      selenium_browser.should_receive(:find_element).and_return(selenium_browser)
-      selenium_browser.should_receive(:text).and_return("Alert")
-      selenium_page_object.alert_span.should == "Alert"
+      expect(selenium_browser).to receive(:find_element).and_return(selenium_browser)
+      expect(selenium_browser).to receive(:text).and_return("Alert")
+      expect(selenium_page_object.alert_span).to eql "Alert"
     end
 
     it "should retrieve the span element from the page" do
-      selenium_browser.should_receive(:find_element).and_return(selenium_browser)
+      expect(selenium_browser).to receive(:find_element).and_return(selenium_browser)
       element = selenium_page_object.alert_span_element
-      element.should be_instance_of PageObject::Elements::Span
+      expect(element).to be_instance_of PageObject::Elements::Span
     end
   end
 
   describe "table accessors" do
     it "should retrieve the table element from the page" do
-      selenium_browser.should_receive(:find_element).and_return(selenium_browser)
+      expect(selenium_browser).to receive(:find_element).and_return(selenium_browser)
       element = selenium_page_object.cart_element
-      element.should be_instance_of(PageObject::Elements::Table)
+      expect(element).to be_instance_of(PageObject::Elements::Table)
     end
   end
 
   describe "table cell accessors" do
     it "should retrieve the text from the cell" do
-      selenium_browser.should_receive(:find_element).and_return(selenium_browser)
-      selenium_browser.should_receive(:text).and_return('celldata')
-      selenium_page_object.total.should == 'celldata'
+      expect(selenium_browser).to receive(:find_element).and_return(selenium_browser)
+      expect(selenium_browser).to receive(:text).and_return('celldata')
+      expect(selenium_page_object.total).to eql 'celldata'
     end
 
     it "should retrieve the cell element from the page" do
-      selenium_browser.should_receive(:find_element).and_return(selenium_browser)
+      expect(selenium_browser).to receive(:find_element).and_return(selenium_browser)
       element = selenium_page_object.total_element
-      element.should be_instance_of PageObject::Elements::TableCell
+      expect(element).to be_instance_of PageObject::Elements::TableCell
     end
   end
 
   describe "image accessors" do
     it "should retrieve the image element from the page" do
-      selenium_browser.should_receive(:find_element).and_return(selenium_browser)
+      expect(selenium_browser).to receive(:find_element).and_return(selenium_browser)
       element = selenium_page_object.logo_element
-      element.should be_instance_of PageObject::Elements::Image
+      expect(element).to be_instance_of PageObject::Elements::Image
     end
   end
 
   describe "form accessors" do
     it "should retrieve the form element from the page" do
-      selenium_browser.should_receive(:find_element).and_return(selenium_browser)
+      expect(selenium_browser).to receive(:find_element).and_return(selenium_browser)
       element = selenium_page_object.login_element
-      element.should be_instance_of PageObject::Elements::Form
+      expect(element).to be_instance_of PageObject::Elements::Form
     end
   end
 
   describe "list item accessors" do
     it "should retrieve the text from the list item" do
-      selenium_browser.should_receive(:find_element).and_return(selenium_browser)
-      selenium_browser.should_receive(:text).and_return("value")
-      selenium_page_object.item_one.should == "value"
+      expect(selenium_browser).to receive(:find_element).and_return(selenium_browser)
+      expect(selenium_browser).to receive(:text).and_return("value")
+      expect(selenium_page_object.item_one).to eql "value"
     end
 
     it "should retrieve the list item from the page" do
-      selenium_browser.should_receive(:find_element).and_return(selenium_browser)
+      expect(selenium_browser).to receive(:find_element).and_return(selenium_browser)
       element = selenium_page_object.item_one_element
-      element.should be_instance_of PageObject::Elements::ListItem
+      expect(element).to be_instance_of PageObject::Elements::ListItem
     end
   end
 
   describe "unordered list accessors" do
     it "should retrieve the element from the page" do
-      selenium_browser.should_receive(:find_element).and_return(selenium_browser)
+      expect(selenium_browser).to receive(:find_element).and_return(selenium_browser)
       element = selenium_page_object.menu_element
-      element.should be_instance_of PageObject::Elements::UnorderedList
+      expect(element).to be_instance_of PageObject::Elements::UnorderedList
     end
   end
 
   describe "ordered list accessors" do
     it "should retrieve the element from the page" do
-      selenium_browser.should_receive(:find_element).and_return(selenium_browser)
+      expect(selenium_browser).to receive(:find_element).and_return(selenium_browser)
       element = selenium_page_object.top_five_element
-      element.should be_instance_of PageObject::Elements::OrderedList
+      expect(element).to be_instance_of PageObject::Elements::OrderedList
     end
   end
   
   describe "h1 accessors" do
     it "should retrieve the text from the h1" do
-      selenium_browser.should_receive(:find_element).and_return(selenium_browser)
-      selenium_browser.should_receive(:text).and_return("value")
-      selenium_page_object.heading1.should == "value"
+      expect(selenium_browser).to receive(:find_element).and_return(selenium_browser)
+      expect(selenium_browser).to receive(:text).and_return("value")
+      expect(selenium_page_object.heading1).to eql "value"
     end
   
     it "should retrieve the element from the page" do
-      selenium_browser.should_receive(:find_element).and_return(selenium_browser)
+      expect(selenium_browser).to receive(:find_element).and_return(selenium_browser)
       element = selenium_page_object.heading1_element
-      element.should be_instance_of PageObject::Elements::Heading
+      expect(element).to be_instance_of PageObject::Elements::Heading
     end
   end
   
   describe "h2 accessors" do
     it "should retrieve the text from the h2" do
-      selenium_browser.should_receive(:find_element).and_return(selenium_browser)
-      selenium_browser.should_receive(:text).and_return("value")
-      selenium_page_object.heading2.should == "value"
+      expect(selenium_browser).to receive(:find_element).and_return(selenium_browser)
+      expect(selenium_browser).to receive(:text).and_return("value")
+      expect(selenium_page_object.heading2).to eql "value"
     end
 
     it "should retrieve the element from the page" do
-      selenium_browser.should_receive(:find_element).and_return(selenium_browser)
+      expect(selenium_browser).to receive(:find_element).and_return(selenium_browser)
       element = selenium_page_object.heading2_element
-      element.should be_instance_of PageObject::Elements::Heading
+      expect(element).to be_instance_of PageObject::Elements::Heading
     end
   end
 
   describe "h3 accessors" do
     it "should retrieve the text from the h3" do
-      selenium_browser.should_receive(:find_element).and_return(selenium_browser)
-      selenium_browser.should_receive(:text).and_return("value")
-      selenium_page_object.heading3.should == "value"
+      expect(selenium_browser).to receive(:find_element).and_return(selenium_browser)
+      expect(selenium_browser).to receive(:text).and_return("value")
+      expect(selenium_page_object.heading3).to eql "value"
     end
 
     it "should retrieve the element from the page" do
-      selenium_browser.should_receive(:find_element).and_return(selenium_browser)
+      expect(selenium_browser).to receive(:find_element).and_return(selenium_browser)
       element = selenium_page_object.heading3_element
-      element.should be_instance_of PageObject::Elements::Heading
+      expect(element).to be_instance_of PageObject::Elements::Heading
     end
   end
 
   describe "h4 accessors" do
     it "should retrieve the text from the h4" do
-      selenium_browser.should_receive(:find_element).and_return(selenium_browser)
-      selenium_browser.should_receive(:text).and_return("value")
-      selenium_page_object.heading4.should == "value"
+      expect(selenium_browser).to receive(:find_element).and_return(selenium_browser)
+      expect(selenium_browser).to receive(:text).and_return("value")
+      expect(selenium_page_object.heading4).to eql "value"
     end
 
     it "should retrieve the element from the page" do
-      selenium_browser.should_receive(:find_element).and_return(selenium_browser)
+      expect(selenium_browser).to receive(:find_element).and_return(selenium_browser)
       element = selenium_page_object.heading4_element
-      element.should be_instance_of PageObject::Elements::Heading
+      expect(element).to be_instance_of PageObject::Elements::Heading
     end
   end
 
   describe "h5 accessors" do
     it "should retrieve the text from the h5" do
-      selenium_browser.should_receive(:find_element).and_return(selenium_browser)
-      selenium_browser.should_receive(:text).and_return("value")
-      selenium_page_object.heading5.should == "value"
+      expect(selenium_browser).to receive(:find_element).and_return(selenium_browser)
+      expect(selenium_browser).to receive(:text).and_return("value")
+      expect(selenium_page_object.heading5).to eql "value"
     end
 
     it "should retrieve the element from the page" do
-      selenium_browser.should_receive(:find_element).and_return(selenium_browser)
+      expect(selenium_browser).to receive(:find_element).and_return(selenium_browser)
       element = selenium_page_object.heading5_element
-      element.should be_instance_of PageObject::Elements::Heading
+      expect(element).to be_instance_of PageObject::Elements::Heading
     end
   end
 
   describe "h6 accessors" do
     it "should retrieve the text from the h6" do
-      selenium_browser.should_receive(:find_element).and_return(selenium_browser)
-      selenium_browser.should_receive(:text).and_return("value")
-      selenium_page_object.heading6.should == "value"
+      expect(selenium_browser).to receive(:find_element).and_return(selenium_browser)
+      expect(selenium_browser).to receive(:text).and_return("value")
+      expect(selenium_page_object.heading6).to eql "value"
     end
 
     it "should retrieve the element from the page" do
-      selenium_browser.should_receive(:find_element).and_return(selenium_browser)
+      expect(selenium_browser).to receive(:find_element).and_return(selenium_browser)
       element = selenium_page_object.heading6_element
-      element.should be_instance_of PageObject::Elements::Heading
+      expect(element).to be_instance_of PageObject::Elements::Heading
     end
   end
 
 
   describe "p accessors" do
     it "should retrieve the text from the p" do
-      selenium_browser.should_receive(:find_element).and_return(selenium_browser)
-      selenium_browser.should_receive(:text).and_return("value")
-      selenium_page_object.first_para.should == "value"
+      expect(selenium_browser).to receive(:find_element).and_return(selenium_browser)
+      expect(selenium_browser).to receive(:text).and_return("value")
+      expect(selenium_page_object.first_para).to eql "value"
     end
 
     it "should retrieve the element from the page" do
-      selenium_browser.should_receive(:find_element).and_return(selenium_browser)
+      expect(selenium_browser).to receive(:find_element).and_return(selenium_browser)
       element = selenium_page_object.first_para_element
-      element.should be_instance_of PageObject::Elements::Paragraph
+      expect(element).to be_instance_of PageObject::Elements::Paragraph
     end
   end
 
   describe "file_field accessors" do
     it "should set the file name" do
-      selenium_browser.should_receive(:find_element).and_return(selenium_browser)
-      selenium_browser.should_receive(:send_keys).with('some_file')
+      expect(selenium_browser).to receive(:find_element).and_return(selenium_browser)
+      expect(selenium_browser).to receive(:send_keys).with('some_file')
       selenium_page_object.upload_me = 'some_file'
     end
 
     it "should retrieve a file_field element" do
-      selenium_browser.should_receive(:find_element).and_return(selenium_browser)
+      expect(selenium_browser).to receive(:find_element).and_return(selenium_browser)
       element = selenium_page_object.upload_me_element
-      element.should be_instance_of PageObject::Elements::FileField
+      expect(element).to be_instance_of PageObject::Elements::FileField
     end
   end
 
   describe "area accessors" do
     context "when called on a page object" do
       it "should generate accessor methods" do
-        selenium_page_object.should respond_to(:img_area)
-        selenium_page_object.should respond_to(:img_area_element)
+        expect(selenium_page_object).to respond_to(:img_area)
+        expect(selenium_page_object).to respond_to(:img_area_element)
       end
 
       it "should call a block on the element method when present" do
-        block_page_object.img_area_element.should == "area"
+        expect(block_page_object.img_area_element).to eql "area"
       end
     end
 
     it "should click on the area" do
-      selenium_browser.should_receive(:find_element).and_return(selenium_browser)
-      selenium_browser.should_receive(:click)
+      expect(selenium_browser).to receive(:find_element).and_return(selenium_browser)
+      expect(selenium_browser).to receive(:click)
       selenium_page_object.img_area
     end
 
     it "should retrieve the element from the page" do
-      selenium_browser.should_receive(:find_element).and_return(selenium_browser)
+      expect(selenium_browser).to receive(:find_element).and_return(selenium_browser)
       element = selenium_page_object.img_area_element
-      element.should be_instance_of PageObject::Elements::Area
+      expect(element).to be_instance_of PageObject::Elements::Area
     end
   end
 
   describe "canvas accessors" do
     context "when called on a page object" do
       it "should generate accessor methods" do
-        selenium_page_object.should respond_to(:my_canvas_element)
+        expect(selenium_page_object).to respond_to(:my_canvas_element)
       end
 
       it "should call a block on the element method when present" do
-        block_page_object.my_canvas_element.should == "canvas"
+        expect(block_page_object.my_canvas_element).to eql "canvas"
       end
     end
   end
@@ -573,11 +571,11 @@ describe PageObject::Accessors do
   describe "audio accessors" do
     context "when called on a page object" do
       it "should generate accessor methods" do
-        selenium_page_object.should respond_to(:acdc_element)
+        expect(selenium_page_object).to respond_to(:acdc_element)
       end
 
       it "should call a block on the element method when present" do
-        block_page_object.acdc_element.should == "audio"
+        expect(block_page_object.acdc_element).to eql "audio"
       end
     end
   end
@@ -585,12 +583,27 @@ describe PageObject::Accessors do
   describe "video accessors" do
     context "when called on a page object" do
       it "should generate accessor methods" do
-        selenium_page_object.should respond_to(:movie_element)
+        expect(selenium_page_object).to respond_to(:movie_element)
       end
 
       it "should call a block on the elmenet method when present" do
-        block_page_object.movie_element.should == "video"
+        expect(block_page_object.movie_element).to eql "video"
       end
     end
   end
+
+  describe "b accessors" do
+    it "should retrieve the text from the b" do
+      expect(selenium_browser).to receive(:find_element).and_return(selenium_browser)
+      expect(selenium_browser).to receive(:text).and_return("value")
+      expect(selenium_page_object.bold).to eql "value"
+    end
+
+    it "should retrieve the element from the page" do
+      expect(selenium_browser).to receive(:find_element).and_return(selenium_browser)
+      element = selenium_page_object.bold_element
+      expect(element).to be_instance_of PageObject::Elements::Bold
+    end
+  end
+
 end