page-object 0.3.2 → 0.4.0

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

@@ -3,213 +3,252 @@ require 'page-object/elements'
 
 
 describe "Element with nested elements" do
-  let(:watir_driver) { double('watir') }
-  let(:watir_element) { PageObject::Elements::Element.new(watir_driver, :platform => :watir_webdriver) }
-  let(:selenium_driver) { double('selenium') }
-  let(:selenium_element) { PageObject::Elements::Element.new(selenium_driver, :platform => :selenium_webdriver) }
-
-
   context "in Watir" do
+    before(:each) do
+      @watir_driver = Watir::Element.new(nil, {})
+      @watir_element = PageObject::Elements::Element.new(@watir_driver, :platform => :watir_webdriver)
+    end
+    
     it "should find nested links" do
-      watir_driver.should_receive(:link).with(:id => 'blah').and_return(watir_driver)
-      watir_element.link_element(:id => 'blah')
+      @watir_driver.should_receive(:link).with(:id => 'blah').and_return(@watir_driver)
+      @watir_element.link_element(:id => 'blah')
     end
 
     it "should find nested buttons" do
-      watir_driver.should_receive(:button).with(:id => 'blah').and_return(watir_driver)
-      watir_element.button_element(:id => 'blah')
+      @watir_driver.should_receive(:button).with(:id => 'blah').and_return(@watir_driver)
+      @watir_element.button_element(:id => 'blah')
     end
     
     it "should find nested text fields" do
-      watir_driver.should_receive(:text_field).with(:id => 'blah').and_return(watir_driver)
-      watir_element.text_field_element(:id => 'blah')
+      @watir_driver.should_receive(:text_field).with(:id => 'blah').and_return(@watir_driver)
+      @watir_element.text_field_element(:id => 'blah')
     end
 
     it "should find nested hidden fields" do
-      watir_driver.should_receive(:hidden).and_return(watir_driver)
-      watir_element.hidden_field_element
+      @watir_driver.should_receive(:hidden).and_return(@watir_driver)
+      @watir_element.hidden_field_element
     end
 
     it "should find nested text areas" do
-      watir_driver.should_receive(:textarea).and_return(watir_driver)
-      watir_element.text_area_element
+      @watir_driver.should_receive(:textarea).and_return(@watir_driver)
+      @watir_element.text_area_element
     end
 
     it "should find a nested select list" do
-      watir_driver.should_receive(:select_list).and_return(watir_driver)
-      watir_element.select_list_element
+      @watir_driver.should_receive(:select_list).and_return(@watir_driver)
+      @watir_element.select_list_element
     end
 
     it "should find a nested checkbox" do
-      watir_driver.should_receive(:checkbox).and_return(watir_driver)
-      watir_element.checkbox_element
+      @watir_driver.should_receive(:checkbox).and_return(@watir_driver)
+      @watir_element.checkbox_element
     end
     
     it "should find a nested radio button" do
-      watir_driver.should_receive(:radio).and_return(watir_driver)
-      watir_element.radio_button_element
+      @watir_driver.should_receive(:radio).and_return(@watir_driver)
+      @watir_element.radio_button_element
     end
     
     it "should find a nested div" do
-      watir_driver.should_receive(:div).and_return(watir_driver)
-      watir_element.div_element
+      @watir_driver.should_receive(:div).and_return(@watir_driver)
+      @watir_element.div_element
     end
     
     it "should find a nested span" do
-      watir_driver.should_receive(:span).and_return(watir_driver)
-      watir_element.span_element
+      @watir_driver.should_receive(:span).and_return(@watir_driver)
+      @watir_element.span_element
     end
     
     it "should find a nested table" do
-      watir_driver.should_receive(:table).and_return(watir_driver)
-      watir_element.table_element
+      @watir_driver.should_receive(:table).and_return(@watir_driver)
+      @watir_element.table_element
     end
 
     it "should find a nested cell" do
-      watir_driver.should_receive(:td).and_return(watir_driver)
-      watir_element.cell_element
+      @watir_driver.should_receive(:td).and_return(@watir_driver)
+      @watir_element.cell_element
     end
     
     it "should find a nested image" do
-      watir_driver.should_receive(:image).and_return(watir_driver)
-      watir_element.image_element
+      @watir_driver.should_receive(:image).and_return(@watir_driver)
+      @watir_element.image_element
     end
     
     it "should find a nested form" do
-      watir_driver.should_receive(:form).and_return(watir_driver)
-      watir_element.form_element
+      @watir_driver.should_receive(:form).and_return(@watir_driver)
+      @watir_element.form_element
     end
     
     it "should find a nested ordered list" do
-      watir_driver.should_receive(:ol).and_return(watir_driver)
-      watir_element.ordered_list_element
+      @watir_driver.should_receive(:ol).and_return(@watir_driver)
+      @watir_element.ordered_list_element
     end
     
     it "should find a nested unordered list" do
-      watir_driver.should_receive(:ul).and_return(watir_driver)
-      watir_element.unordered_list_element
+      @watir_driver.should_receive(:ul).and_return(@watir_driver)
+      @watir_element.unordered_list_element
     end
     
     it "should find a nested list item" do
-      watir_driver.should_receive(:li).and_return(watir_driver)
-      watir_element.list_item_element
+      @watir_driver.should_receive(:li).and_return(@watir_driver)
+      @watir_element.list_item_element
     end
     
     it "should find a nested h1" do
-      watir_driver.should_receive(:h1).and_return(watir_driver)
-      watir_element.h1_element
+      @watir_driver.should_receive(:h1).and_return(@watir_driver)
+      @watir_element.h1_element
     end
 
     it "should find a nested h2" do
-      watir_driver.should_receive(:h2).and_return(watir_driver)
-      watir_element.h2_element
+      @watir_driver.should_receive(:h2).and_return(@watir_driver)
+      @watir_element.h2_element
     end
 
     it "should find a nested h3" do
-      watir_driver.should_receive(:h3).and_return(watir_driver)
-      watir_element.h3_element
+      @watir_driver.should_receive(:h3).and_return(@watir_driver)
+      @watir_element.h3_element
+    end
+
+    it "should find a nested h4" do
+      @watir_driver.should_receive(:h4).and_return(@watir_driver)
+      @watir_element.h4_element
+    end
+
+    it "should find a nested h5" do
+      @watir_driver.should_receive(:h5).and_return(@watir_driver)
+      @watir_element.h5_element
+    end
+
+    it "should find a nested h6" do
+      @watir_driver.should_receive(:h6).and_return(@watir_driver)
+      @watir_element.h6_element
     end
   end
   
   context "in Selenium" do
+    before(:each) do
+      @selenium_driver = double('selenium')
+      @selenium_element = PageObject::Elements::Element.new(@selenium_driver, :platform => :selenium_webdriver)
+    end
+
     it "should find nested links" do
-      selenium_driver.should_receive(:find_element).with(:id, 'blah').and_return(selenium_driver)
-      selenium_element.link_element(:id => 'blah')
+      @selenium_driver.should_receive(:find_element).with(:id, 'blah').and_return(@selenium_driver)
+      @selenium_element.link_element(:id => 'blah')
     end
 
     it "should find nested buttons" do
-      selenium_driver.should_receive(:find_element).with(:id, 'blah').and_return(selenium_driver)
-      selenium_element.button_element(:id => 'blah')
+      @selenium_driver.should_receive(:find_element).with(:id, 'blah').and_return(@selenium_driver)
+      @selenium_element.button_element(:id => 'blah')
     end
     
     it "should find nested text fields" do
-      selenium_driver.should_receive(:find_element).with(:id, 'blah').and_return(selenium_driver)
-      selenium_element.text_field_element(:id => 'blah')
+      @selenium_driver.should_receive(:find_element).with(:id, 'blah').and_return(@selenium_driver)
+      @selenium_element.text_field_element(:id => 'blah')
     end
     
     it "should find nested hidden fields" do
-      selenium_driver.should_receive(:find_element).and_return(selenium_driver)
-      selenium_element.hidden_field_element
+      @selenium_driver.should_receive(:find_element).and_return(@selenium_driver)
+      @selenium_element.hidden_field_element
     end
     
     it "should find nested text areas" do
-      selenium_driver.should_receive(:find_element).and_return(selenium_driver)
-      selenium_element.text_area_element
+      @selenium_driver.should_receive(:find_element).and_return(@selenium_driver)
+      @selenium_element.text_area_element
     end
     
     it "should find a nested select list" do
-      selenium_driver.should_receive(:find_element).and_return(selenium_driver)
-      selenium_element.select_list_element
+      @selenium_driver.should_receive(:find_element).and_return(@selenium_driver)
+      @selenium_element.select_list_element
     end
     
     it "should find a nested checkbox" do
-      selenium_driver.should_receive(:find_element).and_return(selenium_driver)
-      selenium_element.checkbox_element
+      @selenium_driver.should_receive(:find_element).and_return(@selenium_driver)
+      @selenium_element.checkbox_element
     end
     
     it "should find a nested radio button" do
-      selenium_driver.should_receive(:find_element).and_return(selenium_driver)
-      selenium_element.radio_button_element
+      @selenium_driver.should_receive(:find_element).and_return(@selenium_driver)
+      @selenium_element.radio_button_element
     end
     
     it "should find a nested div" do
-      selenium_driver.should_receive(:find_element).and_return(selenium_driver)
-      selenium_element.div_element
+      @selenium_driver.should_receive(:find_element).and_return(@selenium_driver)
+      @selenium_element.div_element
     end
     
     it "should find a nested span" do
-      selenium_driver.should_receive(:find_element).and_return(selenium_driver)
-      selenium_element.span_element
+      @selenium_driver.should_receive(:find_element).and_return(@selenium_driver)
+      @selenium_element.span_element
     end
     
     it "should find a nested table" do
-      selenium_driver.should_receive(:find_element).and_return(selenium_driver)
-      selenium_element.table_element
+      @selenium_driver.should_receive(:find_element).and_return(@selenium_driver)
+      @selenium_element.table_element
     end
 
     it "should find a nested cell" do
-      selenium_driver.should_receive(:find_element).and_return(selenium_driver)
-      selenium_element.cell_element
+      @selenium_driver.should_receive(:find_element).and_return(@selenium_driver)
+      @selenium_element.cell_element
     end
     
     it "should find a nested image" do
-      selenium_driver.should_receive(:find_element).and_return(selenium_driver)
-      selenium_element.image_element
+      @selenium_driver.should_receive(:find_element).and_return(@selenium_driver)
+      @selenium_element.image_element
     end
     
     it "should find a nested form" do
-      selenium_driver.should_receive(:find_element).and_return(selenium_driver)
-      selenium_element.form_element
+      @selenium_driver.should_receive(:find_element).and_return(@selenium_driver)
+      @selenium_element.form_element
     end
     
     it "should find an ordered list" do
-      selenium_driver.should_receive(:find_element).and_return(selenium_driver)
-      selenium_element.ordered_list_element
+      @selenium_driver.should_receive(:find_element).and_return(@selenium_driver)
+      @selenium_element.ordered_list_element
     end
     
     it "should find an unordered list" do
-      selenium_driver.should_receive(:find_element).and_return(selenium_driver)
-      selenium_element.unordered_list_element
+      @selenium_driver.should_receive(:find_element).and_return(@selenium_driver)
+      @selenium_element.unordered_list_element
     end
     
     it "should find a nested list item" do
-      selenium_driver.should_receive(:find_element).and_return(selenium_driver)
-      selenium_element.list_item_element
+      @selenium_driver.should_receive(:find_element).and_return(@selenium_driver)
+      @selenium_element.list_item_element
     end
     
     it "should find a nested h1" do
-      selenium_driver.should_receive(:find_element).and_return(selenium_driver)
-      selenium_element.h1_element
+      @selenium_driver.should_receive(:find_element).and_return(@selenium_driver)
+      @selenium_element.h1_element
     end
     
     it "should find a nested h2" do
-      selenium_driver.should_receive(:find_element).and_return(selenium_driver)
-      selenium_element.h2_element
+      @selenium_driver.should_receive(:find_element).and_return(@selenium_driver)
+      @selenium_element.h2_element
     end
 
     it "should find a nested h3" do
-      selenium_driver.should_receive(:find_element).and_return(selenium_driver)
-      selenium_element.h3_element
+      @selenium_driver.should_receive(:find_element).and_return(@selenium_driver)
+      @selenium_element.h3_element
+    end
+
+    it "should find a nested h4" do
+      @selenium_driver.should_receive(:find_element).and_return(@selenium_driver)
+      @selenium_element.h4_element
+    end
+
+    it "should find a nested h5" do
+      @selenium_driver.should_receive(:find_element).and_return(@selenium_driver)
+      @selenium_element.h5_element
+    end
+
+    it "should find a nested h6" do
+      @selenium_driver.should_receive(:find_element).and_return(@selenium_driver)
+      @selenium_element.h6_element
+    end
+
+    it "should find a nested paragraph" do
+      @selenium_driver.should_receive(:find_element).and_return(@selenium_driver)
+      @selenium_element.paragraph_element
     end
   end
 end

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

@@ -0,0 +1,128 @@
+
+describe "Element for Selenium" do
+  before(:each) do
+    @selenium_driver = double('selenium')
+    @selenium_element = ::PageObject::Elements::Element.new(@selenium_driver, :platform => :selenium_webdriver)
+  end
+
+  it "should know when it is visible" do
+    @selenium_driver.should_receive(:displayed?).and_return(true)
+    @selenium_element.visible?.should == true
+  end
+
+  it "should know when it is not visible" do
+    @selenium_driver.should_receive(:displayed?).and_return(false)
+    @selenium_element.visible?.should == false
+  end
+
+  it "should know when it exists" do
+    @selenium_element.exists?.should == 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
+  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"
+  end
+
+  it "should know when it is equal to another" do
+    @selenium_driver.should_receive(:==).and_return(true)
+    @selenium_element.should == @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"
+  end
+
+  it "should know its value" do
+    @selenium_driver.should_receive(:attribute).with('value').and_return("value")
+    @selenium_element.value.should == "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
+  end
+
+  it "should be clickable" do
+    @selenium_driver.should_receive(:click)
+    @selenium_element.click
+  end
+
+  it "should be double clickable" do
+    @selenium_driver.should_receive(:double_click)
+    @selenium_element.double_click
+  end
+  
+  it "should be right clickable" do
+    @selenium_driver.should_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)
+    @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)
+    element = @selenium_element.when_present(10)
+    element.should === @selenium_element
+  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)
+    @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)
+    element = @selenium_element.when_visible(10)
+    element.should === @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)
+    @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)
+    element = @selenium_element.when_not_visible(10)
+    element.should === @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)
+    @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'])
+    @selenium_element.send_keys([:control, 'a'])
+  end
+  
+  it "should clear its' contents" do
+    @selenium_driver.should_receive(:clear)
+    @selenium_element.clear
+  end
+end

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

@@ -0,0 +1,116 @@
+require 'spec_helper'
+
+describe "Element for Watir" do
+  before(:each) do
+    @watir_driver = ::Watir::Element.new(nil, {})
+    @watir_element = ::PageObject::Elements::Element.new(@watir_driver, :platform => :watir_webdriver)
+  end
+  
+  it "should know when it is visible" do
+    @watir_driver.should_receive(:present?).and_return(true)
+    @watir_element.visible?.should == true
+  end
+
+  it "should know when it is not visible" do
+    @watir_driver.should_receive(:present?).and_return(false)
+    @watir_element.visible?.should == false
+  end
+
+  it "should know when it exists" do
+    @watir_driver.should_receive(:exists?).and_return(true)
+    @watir_element.exists?.should == true
+  end
+
+  it "should know when it does not exist" do
+    @watir_driver.should_receive(:exists?).and_return(false)
+    @watir_element.exists?.should == false
+  end
+
+  it "should be able to return the text contained in the element" do
+    @watir_driver.should_receive(:text).and_return("my text")
+    @watir_element.text.should == "my text"
+  end
+
+  it "should know when it is equal to another" do
+    @watir_driver.should_receive(:==).and_return(true)
+    @watir_element.should == @watir_element
+  end
+
+  it "should return its tag name" do
+    @watir_driver.should_receive(:tag_name).and_return("h1")
+    @watir_element.tag_name.should == "h1"
+  end
+
+  it "should know its value" do
+    @watir_driver.should_receive(:value).and_return("value")
+    @watir_element.value.should == "value"
+  end
+
+  it "should know how to retrieve the value of an attribute" do
+    @watir_driver.should_receive(:attribute_value).and_return(true)
+    @watir_element.attribute("readonly").should be_true
+  end
+
+  it "should be clickable" do
+    @watir_driver.should_receive(:click)
+    @watir_element.click
+  end
+  
+  it "should be double clickable" do
+    @watir_driver.should_receive(:double_click)
+    @watir_element.double_click
+  end
+  
+  it "should be right clickable" do
+    @watir_driver.should_receive(:right_click)
+    @watir_element.right_click
+  end
+
+  it "should be able to block until it is present" do
+    @watir_driver.should_receive(:wait_until_present).with(10)
+    @watir_element.when_present(10)
+  end
+  
+  it "should return the element when it is present" do
+    @watir_driver.should_receive(:wait_until_present).with(10)
+    element = @watir_element.when_present(10)
+    element.should === @watir_element
+  end
+
+  it "should be able to block until it is visible" do
+    ::Watir::Wait.should_receive(:until).with(10, "Element was not visible in 10 seconds")
+    @watir_element.when_visible(10)
+  end
+  
+  it "should return the element when it is visible" do
+    ::Watir::Wait.should_receive(:until).with(10, "Element was not visible in 10 seconds")
+    element = @watir_element.when_visible(10)
+    element.should === @watir_element
+  end
+
+  it "should be able to block until it is not visible" do
+    ::Watir::Wait.should_receive(:while).with(10, "Element still visible after 10 seconds")
+    @watir_element.when_not_visible(10)
+  end
+  
+  it "should return the element when it is not visible" do
+    ::Watir::Wait.should_receive(:while).with(10, "Element still visible after 10 seconds")
+    element = @watir_element.when_not_visible(10)
+    element.should === @watir_element
+  end
+
+  it "should be able to block until a user define event fires true" do
+    ::Watir::Wait.should_receive(:until).with(10, "Element blah")
+    @watir_element.wait_until(10, "Element blah") {}
+  end
+  
+  it "should send keys to the element" do
+    @watir_driver.should_receive(:send_keys).with([:control, 'a'])
+    @watir_element.send_keys([:control, 'a'])
+  end
+  
+  it "should clear its' contents" do
+    @watir_driver.should_receive(:clear)
+    @watir_element.clear
+  end
+end

data/spec/page-object/page-object_spec.rb

@@ -140,6 +140,22 @@ describe PageObject do
         watir_browser.should_receive(:forward)
         watir_page_object.forward
       end
+      
+      it "should know its' current url" do
+        watir_browser.should_receive(:url).and_return("cheezyworld.com")
+        watir_page_object.current_url.should == "cheezyworld.com"
+      end
+      
+      it "should know how to clear all of the cookies from the browser" do
+        watir_browser.should_receive(:clear_cookies)
+        watir_page_object.clear_cookies
+      end
+      
+      it "should be able to save a screenshot" do
+        watir_browser.should_receive(:wd).and_return(watir_browser)
+        watir_browser.should_receive(:save_screenshot)
+        watir_page_object.save_screenshot("test.png")
+      end
     end
 
     context "when using SeleniumPageObject" do
@@ -225,6 +241,22 @@ describe PageObject do
         selenium_browser.should_receive(:forward)
         selenium_page_object.forward
       end
+      
+      it "should know its' current url" do
+        selenium_browser.should_receive(:current_url).and_return("cheezyworld.com")
+        selenium_page_object.current_url.should == "cheezyworld.com"
+      end
+      
+      it "should clear all of the cookies from the browser" do
+        selenium_browser.should_receive(:manage).and_return(selenium_browser)
+        selenium_browser.should_receive(:delete_all_cookies)
+        selenium_page_object.clear_cookies
+      end
+      
+      it "should be able to save a screenshot" do
+        selenium_browser.should_receive(:save_screenshot)
+        selenium_page_object.save_screenshot("test.png")
+      end
     end
   end
 end