page-object 1.0.2 → 1.0.3

data/spec/page-object/page_factory_spec.rb

@@ -50,55 +50,55 @@ describe PageObject::PageFactory do
     class NoPO
     end
     @world.on(NoPO)
-    @world.super_called.should be true
+    expect(@world.super_called).to be true
   end
 
   it "should create a new page object and execute a block" do
-    @world.browser.should_not_receive(:goto)
+    expect(@world.browser).not_to receive(:goto)
     @world.on_page FactoryTestPage do |page|
-      page.should be_instance_of FactoryTestPage
+      expect(page).to be_instance_of FactoryTestPage
     end
     @world.on_page "FactoryTestPage" do |page|
-      page.should be_instance_of FactoryTestPage
+      expect(page).to be_instance_of FactoryTestPage
     end
     @world.on_page "ContainingModule::PageInsideModule" do |page|
-      page.should be_instance_of ContainingModule::PageInsideModule
+      expect(page).to be_instance_of ContainingModule::PageInsideModule
     end
   end
 
   it "should create a new page object and execute a block using 'on'" do
-    @world.browser.should_not_receive(:goto)
+    expect(@world.browser).not_to receive(:goto)
     @world.on FactoryTestPage do |page|
-      page.should be_instance_of FactoryTestPage
+      expect(page).to be_instance_of FactoryTestPage
     end
     @world.on "FactoryTestPage" do |page|
-      page.should be_instance_of FactoryTestPage
+      expect(page).to be_instance_of FactoryTestPage
     end
     @world.on "ContainingModule::PageInsideModule" do |page|
-      page.should be_instance_of ContainingModule::PageInsideModule
+      expect(page).to be_instance_of ContainingModule::PageInsideModule
     end
   end
 
   it "should create and visit a new page" do
-    @world.browser.should_receive(:goto).exactly(3).times
+    expect(@world.browser).to receive(:goto).exactly(3).times
     @world.visit_page FactoryTestPage do |page|
-      page.should be_instance_of FactoryTestPage
+      expect(page).to be_instance_of FactoryTestPage
     end
     @world.visit_page "FactoryTestPage" do |page|
-      page.should be_instance_of FactoryTestPage
+      expect(page).to be_instance_of FactoryTestPage
     end
     @world.visit_page "ContainingModule::PageInsideModule" do |page|
-      page.should be_instance_of ContainingModule::PageInsideModule
+      expect(page).to be_instance_of ContainingModule::PageInsideModule
     end
   end
 
   it "should merge params with the class level params if provided when visiting" do
-    @world.browser.should_receive(:goto)
+    expect(@world.browser).to receive(:goto)
     FactoryTestPage.params = {:initial => :value}
     @world.visit_page(FactoryTestPage, :using_params => {:new_value => :merged})
     merged = FactoryTestPage.instance_variable_get("@merged_params")
-    merged[:initial].should == :value
-    merged[:new_value].should == :merged
+    expect(merged[:initial]).to eql :value
+    expect(merged[:new_value]).to eql :merged
   end
 
   it "should use the params in the url when they are provided" do
@@ -106,7 +106,7 @@ describe PageObject::PageFactory do
       include PageObject
       page_url "http://google.com/<%=params[:value]%>"
     end
-    @world.browser.should_receive(:goto).with("http://google.com/PageObject")
+    expect(@world.browser).to receive(:goto).with("http://google.com/PageObject")
     @world.visit_page(PageUsingParams, :using_params => {:value => 'PageObject'})
   end
 
@@ -115,34 +115,34 @@ describe PageObject::PageFactory do
       include PageObject
       page_url "http://google.com/#{1+2}/<%=params[:value]%>"
     end
-    @world.browser.should_receive(:goto).with("http://google.com/3/PageObject")
+    expect(@world.browser).to receive(:goto).with("http://google.com/3/PageObject")
     @world.visit_page(PageUsingParmsAndInterpolated, :using_params => {:value => 'PageObject'})
   end
 
   it "should create and visit a new page using 'visit'" do
-    @world.browser.should_receive(:goto).exactly(3).times
+    expect(@world.browser).to receive(:goto).exactly(3).times
     @world.visit FactoryTestPage do |page|
-      page.should be_instance_of FactoryTestPage
+      expect(page).to be_instance_of FactoryTestPage
     end
     @world.visit "FactoryTestPage" do |page|
-      page.should be_instance_of FactoryTestPage
+      expect(page).to be_instance_of FactoryTestPage
     end
     @world.visit "ContainingModule::PageInsideModule" do |page|
-      page.should be_instance_of ContainingModule::PageInsideModule
+      expect(page).to be_instance_of ContainingModule::PageInsideModule
     end
   end
 
   it "should create and visit a new page when url is defined as 'direct_url'" do
-    @world.browser.should_receive(:goto)
+    expect(@world.browser).to receive(:goto)
     @world.visit TestPageWithDirectUrl do |page|
-      page.should be_instance_of TestPageWithDirectUrl
+      expect(page).to be_instance_of TestPageWithDirectUrl
     end
   end
   
   it "should set an instance variable that can be used outside of the block" do
     page = @world.on_page FactoryTestPage
     current_page = @world.instance_variable_get "@current_page"
-    current_page.should === page
+    expect(current_page).to equal page
   end
 
   it "should not execute block if page is not @current_page" do
@@ -161,9 +161,9 @@ describe PageObject::PageFactory do
   it "should return the @current_page if asking for another page" do
     expected = TestPageWithDirectUrl.new(@world.browser)
     @world.instance_variable_set "@current_page", expected
-    @world.if_page(FactoryTestPage).should == expected
-    @world.if_page("FactoryTestPage").should == expected
-    @world.if_page("ContainingModule::PageInsideModule").should == expected
+    expect(@world.if_page(FactoryTestPage)).to eql expected
+    expect(@world.if_page("FactoryTestPage")).to eql expected
+    expect(@world.if_page("ContainingModule::PageInsideModule")).to eql expected
   end
 
   it "should execute the block when we ask if it is the correct page" do
@@ -171,25 +171,25 @@ describe PageObject::PageFactory do
     
     done = false
     @world.if_page(FactoryTestPage) do |page|
-      page.should be_instance_of FactoryTestPage
+      expect(page).to be_instance_of FactoryTestPage
       done = true 
     end
-    done.should be true
+    expect(done).to be true
     
     done = false
     @world.if_page("FactoryTestPage") do |page|
-      page.should be_instance_of FactoryTestPage
+      expect(page).to be_instance_of FactoryTestPage
       done = true
     end
-    done.should be true
+    expect(done).to be true
     
     done = false
     @world.instance_variable_set "@current_page", ContainingModule::PageInsideModule.new(@world.browser) 
     @world.if_page("ContainingModule::PageInsideModule") do |page|
-      page.should be_instance_of ContainingModule::PageInsideModule
+      expect(page).to be_instance_of ContainingModule::PageInsideModule
       done = true
     end
-    done.should be true
+    expect(done).to be true
   end
 
   it "should raise an error when you do not provide a default route" do
@@ -199,25 +199,25 @@ describe PageObject::PageFactory do
   it "should store the routes" do
     routes = ['a', 'b', 'c']
     PageObject::PageFactory.routes = {:default => routes}
-    PageObject::PageFactory.routes[:default].should == routes
+    expect(PageObject::PageFactory.routes[:default]).to eql routes
   end
 
   it "should navigate to a page calling the default methods" do
     pages = [[FactoryTestPage, :a_method], [AnotherPage, :b_method]]
     PageObject::PageFactory.routes = {:default => pages}
     fake_page = double('a_page')
-    FactoryTestPage.should_receive(:new).and_return(fake_page)
-    fake_page.should_receive(:a_method)
-    @world.navigate_to(AnotherPage).class.should == AnotherPage
+    expect(FactoryTestPage).to receive(:new).and_return(fake_page)
+    expect(fake_page).to receive(:a_method)
+    expect(@world.navigate_to(AnotherPage).class).to eql AnotherPage
   end
 
   it "should pass parameters to methods when navigating" do
     pages = [[FactoryTestPage, :a_method, 'blah'], [AnotherPage, :b_method]]
     PageObject::PageFactory.routes = {:default => pages}
     fake_page = double('a_page')
-    FactoryTestPage.should_receive(:new).and_return(fake_page)
-    fake_page.should_receive(:a_method).with('blah')
-    @world.navigate_to(AnotherPage).class.should == AnotherPage
+    expect(FactoryTestPage).to receive(:new).and_return(fake_page)
+    expect(fake_page).to receive(:a_method).with('blah')
+    expect(@world.navigate_to(AnotherPage).class).to eql AnotherPage
   end
 
   it "should fail when it does not find a proper route" do
@@ -230,27 +230,9 @@ describe PageObject::PageFactory do
       :default => [[FactoryTestPage, :a_method], [AnotherPage, :b_method]]
     }
     fake_page = double('a_page')
-    FactoryTestPage.should_receive(:new).and_return(fake_page)
-    fake_page.should_receive(:respond_to?).with(:a_method).and_return(false)
+    expect(FactoryTestPage).to receive(:new).and_return(fake_page)
+    expect(fake_page).to receive(:respond_to?).with(:a_method).and_return(false)
     expect { @world.navigate_to(AnotherPage) }.to raise_error
   end
 
-  it "should know how to continue routing from a location" do
-    PageObject::PageFactory.routes = {
-      :default => [[FactoryTestPage, :a_method],
-                   [AnotherPage, :b_method],
-                   [YetAnotherPage, :c_method]]
-    }
-
-    @world.current_page = FactoryTestPage.new(@world.browser)
-    f_page = FactoryTestPage.new(@world.browser)
-    FactoryTestPage.should_receive(:new).and_return(f_page)
-    f_page.should_receive(:respond_to?).with(:a_method).and_return(true)
-    f_page.should_receive(:a_method)
-    a_page = AnotherPage.new(@world.browser)
-    AnotherPage.should_receive(:new).and_return(a_page)
-    a_page.should_receive(:respond_to?).with(:b_method).and_return(true)
-    a_page.should_receive(:b_method)
-    @world.continue_navigation_to(YetAnotherPage).class.should == YetAnotherPage
-  end
 end

data/spec/page-object/page_populator_spec.rb

@@ -17,112 +17,106 @@ describe PageObject::PagePopulator  do
   let(:page_object) { PageObjectTestPageObject.new(browser) }
 
   it "should set a value in a text field" do
-    page_object.should_receive(:tf=).with('value')
-    page_object.stub(:is_enabled?).and_return(true)
+    expect(page_object).to receive(:tf=).with('value')
+    allow(page_object).to receive(:is_enabled?).and_return(true)
     page_object.populate_page_with('tf' => 'value')
   end
 
   it "should not set a value in a text field if it is not found on the page" do
-    browser.should_not_receive(:text_field)
+    expect(browser).not_to receive(:text_field)
     page_object.populate_page_with('coffee' => 'value')
   end
 
   it "should not populate a text field when it is disabled" do
-    page_object.should_not_receive(:tf=)
-    page_object.should_receive(:tf_element).twice.and_return(browser)
-    browser.should_receive(:enabled?).and_return(false)
-    browser.should_receive(:tag_name).and_return('input')
+    expect(page_object).not_to receive(:tf=)
+    expect(page_object).to receive(:tf_element).twice.and_return(browser)
+    expect(browser).to receive(:enabled?).and_return(false)
+    expect(browser).to receive(:tag_name).and_return('input')
     page_object.populate_page_with('tf' => true)
   end
 
   it "should not populate a text field when it is not visible" do
-    page_object.should_not_receive(:tf=)
-    page_object.should_receive(:tf_element).twice.and_return(browser)
-    browser.should_receive(:enabled?).and_return(true)
-    browser.should_receive(:visible?).and_return(false)
-    browser.should_receive(:tag_name).and_return('input')
+    expect(page_object).not_to receive(:tf=)
+    expect(page_object).to receive(:tf_element).twice.and_return(browser)
+    expect(browser).to receive(:enabled?).and_return(true)
+    expect(browser).to receive(:visible?).and_return(false)
+    expect(browser).to receive(:tag_name).and_return('input')
     page_object.populate_page_with('tf' => true)
   end
 
   it "should set a value in a text area" do
-    page_object.should_receive(:ta=).with('value')
-    page_object.should_receive(:ta_element).and_return(browser)
-    browser.should_receive(:tag_name).and_return('textarea')
+    expect(page_object).to receive(:ta=).with('value')
+    expect(page_object).to receive(:ta_element).and_return(browser)
+    expect(browser).to receive(:tag_name).and_return('textarea')
     page_object.populate_page_with('ta' => 'value')
   end
 
   it "should set a value in a select list" do
-    page_object.should_receive(:sl=).with('value')
-    page_object.stub(:is_enabled?).and_return(true)
+    expect(page_object).to receive(:sl=).with('value')
+    allow(page_object).to receive(:is_enabled?).and_return(true)
     page_object.populate_page_with('sl' => 'value')
   end
 
   it "should set a value in a file field" do
-    page_object.should_receive(:ff=).with('value')
-    page_object.stub(:is_enabled?).and_return(true)
+    expect(page_object).to receive(:ff=).with('value')
+    allow(page_object).to receive(:is_enabled?).and_return(true)
     page_object.populate_page_with('ff' => 'value')
   end
 
   it "should check a checkbox to true is specified" do
-    page_object.should_receive(:check_cb)
-    page_object.stub(:is_enabled?).and_return(true)
+    expect(page_object).to receive(:check_cb)
+    allow(page_object).to receive(:is_enabled?).and_return(true)
     page_object.populate_page_with('cb' => true)
   end
 
   it "should uncheck a checkbox to false is specified" do
-    page_object.should_receive(:uncheck_cb)
-    page_object.stub(:is_enabled?).and_return(true)
+    expect(page_object).to receive(:uncheck_cb)
+    allow(page_object).to receive(:is_enabled?).and_return(true)
     page_object.populate_page_with('cb' => false)
   end
 
   it "should select a radio button when true is specified" do
-    page_object.should_receive(:select_rb)
-    page_object.stub(:is_enabled?).and_return(true)
+    expect(page_object).to receive(:select_rb)
+    allow(page_object).to receive(:is_enabled?).and_return(true)
     page_object.populate_page_with('rb' => true)
   end
 
-  it "should clear a radio button when false is specified" do
-    page_object.should_receive(:clear_rb)
-    page_object.stub(:is_enabled?).and_return(true)
-    page_object.populate_page_with('rb' => false)
-  end
-
   it "should select the correct element from a radio button group" do
-    page_object.should_receive(:select_rbg).with('blah')
+    expect(page_object).to receive(:select_rbg).with('blah')
     page_object.populate_page_with('rbg' => 'blah')
   end
 
   it "should not populate a checkbox if it is disabled" do
-    page_object.should_not_receive(:check_cb)
-    page_object.should_receive(:cb_element).twice.and_return(browser)
-    browser.should_receive(:enabled?).and_return(false)
-    browser.should_receive(:tag_name).and_return('input')
+    expect(page_object).not_to receive(:check_cb)
+    expect(page_object).to receive(:cb_element).twice.and_return(browser)
+    expect(browser).to receive(:enabled?).and_return(false)
+    expect(browser).to receive(:tag_name).and_return('input')
     page_object.populate_page_with('cb' => true)
   end
 
   it "should not populate a checkbox if it is not visible" do
-    page_object.should_not_receive(:check_cb)
-    page_object.should_receive(:cb_element).twice.and_return(browser)
-    browser.should_receive(:enabled?).and_return(true)
-    browser.should_receive(:visible?).and_return(false)
-    browser.should_receive(:tag_name).and_return('input')
+    expect(page_object).not_to receive(:check_cb)
+    expect(page_object).to receive(:cb_element).twice.and_return(browser)
+    expect(browser).to receive(:enabled?).and_return(true)
+    expect(browser).to receive(:visible?).and_return(false)
+    expect(browser).to receive(:tag_name).and_return('input')
     page_object.populate_page_with('cb' => true)
   end
 
   it "should not populate a radio button when it is disabled" do
-    page_object.should_not_receive(:select_rb)
-    page_object.should_receive(:rb_element).twice.and_return(browser)
-    browser.should_receive(:enabled?).and_return(false)
-    browser.should_receive(:tag_name).and_return('input')
+    expect(page_object).not_to receive(:select_rb)
+    expect(page_object).to receive(:rb_element).twice.and_return(browser)
+    expect(browser).to receive(:enabled?).and_return(false)
+    expect(browser).to receive(:tag_name).and_return('input')
     page_object.populate_page_with('rb' => true)
   end
 
   it "should not populate a radio button when it is not visible" do
-    page_object.should_not_receive(:select_rb)
-    page_object.should_receive(:rb_element).twice.and_return(browser)
-    browser.should_receive(:enabled?).and_return(true)
-    browser.should_receive(:visible?).and_return(false)
-    browser.should_receive(:tag_name).and_return('input')
+    expect(page_object).not_to receive(:select_rb)
+    expect(page_object).to receive(:rb_element).twice.and_return(browser)
+    expect(browser).to receive(:enabled?).and_return(true)
+    expect(browser).to receive(:visible?).and_return(false)
+    expect(browser).to receive(:tag_name).and_return('input')
     page_object.populate_page_with('rb' => true)
   end
 end

data/spec/page-object/platforms/selenium_webdriver/selenium_page_object_spec.rb

@@ -11,55 +11,55 @@ describe PageObject::Platforms::SeleniumWebDriver::PageObject do
   let(:selenium_page_object) { SeleniumTestPageObject.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
 
   context "when building identifiers hash" do
     it "should add tag_name when identifying by text for hidden_field" do
       expected_identifier = {:text => 'foo', :tag_name => 'input', :type => 'hidden'}
-      PageObject::Elements::HiddenField.should_receive(:selenium_identifier_for).with(expected_identifier)
-      selenium_browser.should_receive(:find_element)
+      expect(PageObject::Elements::HiddenField).to receive(:selenium_identifier_for).with(expected_identifier)
+      expect(selenium_browser).to receive(:find_element)
       selenium_page_object.platform.hidden_field_for(:text => 'foo')
     end
 
     it "should add tag_name when identifying by href for anchor" do
       expected_identifier = {:href => 'foo', :tag_name => 'a'}
-      PageObject::Elements::Link.should_receive(:selenium_identifier_for).with(expected_identifier)
-      selenium_browser.should_receive(:find_element)
+      expect(PageObject::Elements::Link).to receive(:selenium_identifier_for).with(expected_identifier)
+      expect(selenium_browser).to receive(:find_element)
       selenium_page_object.platform.link_for(:href => 'foo')
     end
     
     it "should add tag_name when identifying by text for div" do
       expected_identifier = {:text => 'foo', :tag_name => 'div'}
-      PageObject::Elements::Div.should_receive(:selenium_identifier_for).with(expected_identifier)
-      selenium_browser.should_receive(:find_element)
+      expect(PageObject::Elements::Div).to receive(:selenium_identifier_for).with(expected_identifier)
+      expect(selenium_browser).to receive(:find_element)
       selenium_page_object.platform.div_for(:text => 'foo')
     end
   end
 
   context "when trying to find an element that does not exist" do
     it "should return a surogate selenium object" do
-      selenium_browser.should_receive(:find_element).and_raise(Selenium::WebDriver::Error::NoSuchElementError)
+      expect(selenium_browser).to receive(:find_element).and_raise(Selenium::WebDriver::Error::NoSuchElementError)
       page = SeleniumTestPageObject.new(selenium_browser)
       element = page.link_element(:text => 'blah')
-      element.element.should be_instance_of PageObject::Platforms::SeleniumWebDriver::SurrogateSeleniumElement
+      expect(element.element).to be_instance_of PageObject::Platforms::SeleniumWebDriver::SurrogateSeleniumElement
     end
 
     it "should know it is not exist" do
-      selenium_browser.should_receive(:find_element).twice.and_raise(Selenium::WebDriver::Error::NoSuchElementError)
+      expect(selenium_browser).to receive(:find_element).twice.and_raise(Selenium::WebDriver::Error::NoSuchElementError)
       page = SeleniumTestPageObject.new(selenium_browser)
-      page.link_element(:text => 'blah').element.exists?.should be false
+      expect(page.link_element(:text => 'blah').element.exists?).to be false
     end
 
     it "should know it is not visible" do
-      selenium_browser.should_receive(:find_element).twice.and_raise(Selenium::WebDriver::Error::NoSuchElementError)
+      expect(selenium_browser).to receive(:find_element).twice.and_raise(Selenium::WebDriver::Error::NoSuchElementError)
       page = SeleniumTestPageObject.new(selenium_browser)
-      page.link_element(:text => 'blah').element.should_not be_visible
+      expect(page.link_element(:text => 'blah').element).not_to be_visible
     end
 
     it "should raise an error when actions are requested" do
-      selenium_browser.should_receive(:find_element).and_raise(Selenium::WebDriver::Error::NoSuchElementError)
+      expect(selenium_browser).to receive(:find_element).and_raise(Selenium::WebDriver::Error::NoSuchElementError)
       page = SeleniumTestPageObject.new(selenium_browser)
       element = page.link_element(:text => 'blah')
       expect { element.text }.to raise_error