page-object 0.3.2 → 0.4.0

data/spec/page-object/accessors_spec.rb

@@ -24,6 +24,10 @@ class AccessorsTestPageObject
   h1(:heading1, :id => 'main_heading')
   h2(:heading2, :id => 'main_heading')
   h3(:heading3, :id => 'main_heading')
+  h4(:heading4, :id => 'main_heading')
+  h5(:heading5, :id => 'main_heading')
+  h6(:heading6, :id => 'main_heading')
+  paragraph(:first_para, :id => 'first')
 end
 
 class BlockPageObject
@@ -91,6 +95,18 @@ class BlockPageObject
   h3 :heading3 do |element|
     "h3"
   end
+  h4 :heading4 do |element|
+    "h4"
+  end
+  h5 :heading5 do |element|
+    "h5"
+  end
+  h6 :heading6 do |element|
+    "h6"
+  end
+  paragraph :first_para do |element|
+    "p"
+  end
 end
 
 describe PageObject::Accessors do
@@ -953,45 +969,210 @@ describe PageObject::Accessors do
         element.should be_instance_of PageObject::Elements::Heading
       end
     end
+  end
+
+  describe "h3 accessors" do
+    context "when called on a page object" do
+      it "should generate accessor methods" do
+        watir_page_object.should respond_to(:heading3)
+        watir_page_object.should respond_to(:heading3_element)
+      end
+
+      it "should call a block on the element method when present" do
+        block_page_object.heading3_element.should == "h3"
+      end
+    end
+
+    context "watir implementation" do
+      it "should retrieve the text from the h3" do
+        watir_browser.should_receive(:h3).and_return(watir_browser)
+        watir_browser.should_receive(:text).and_return("value")
+        watir_page_object.heading3.should == "value"        
+      end
+
+      it "should retrieve the element from the page" do
+        watir_browser.should_receive(:h3).and_return(watir_browser)
+        element = watir_page_object.heading3_element
+        element.should be_instance_of PageObject::Elements::Heading
+      end
+    end
+
+    context "selenium implementation" 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"
+      end
+
+      it "should retrieve the element from the page" do
+        selenium_browser.should_receive(:find_element).and_return(selenium_browser)
+        element = selenium_page_object.heading3_element
+        element.should be_instance_of PageObject::Elements::Heading
+      end
+    end
+  end
+
+  describe "h4 accessors" do
+    context "when called on a page object" do
+      it "should generate accessor methods" do
+        watir_page_object.should respond_to(:heading4)
+        watir_page_object.should respond_to(:heading4_element)
+      end
+
+      it "should call a block on the element method when present" do
+        block_page_object.heading4_element.should == "h4"
+      end
+    end
+
+    context "watir implementation" do
+      it "should retrieve the text from the h4" do
+        watir_browser.should_receive(:h4).and_return(watir_browser)
+        watir_browser.should_receive(:text).and_return("value")
+        watir_page_object.heading4.should == "value"        
+      end
+
+      it "should retrieve the element from the page" do
+        watir_browser.should_receive(:h4).and_return(watir_browser)
+        element = watir_page_object.heading4_element
+        element.should be_instance_of PageObject::Elements::Heading
+      end
+    end
+
+    context "selenium implementation" 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"
+      end
+
+      it "should retrieve the element from the page" do
+        selenium_browser.should_receive(:find_element).and_return(selenium_browser)
+        element = selenium_page_object.heading4_element
+        element.should be_instance_of PageObject::Elements::Heading
+      end
+    end
+  end
+
+  describe "h5 accessors" do
+    context "when called on a page object" do
+      it "should generate accessor methods" do
+        watir_page_object.should respond_to(:heading5)
+        watir_page_object.should respond_to(:heading5_element)
+      end
+
+      it "should call a block on the element method when present" do
+        block_page_object.heading5_element.should == "h5"
+      end
+    end
+
+    context "watir implementation" do
+      it "should retrieve the text from the h5" do
+        watir_browser.should_receive(:h5).and_return(watir_browser)
+        watir_browser.should_receive(:text).and_return("value")
+        watir_page_object.heading5.should == "value"        
+      end
+
+      it "should retrieve the element from the page" do
+        watir_browser.should_receive(:h5).and_return(watir_browser)
+        element = watir_page_object.heading5_element
+        element.should be_instance_of PageObject::Elements::Heading
+      end
+    end
 
-    describe "h3 accessors" do
-      context "when called on a page object" do
-        it "should generate accessor methods" do
-          watir_page_object.should respond_to(:heading3)
-          watir_page_object.should respond_to(:heading3_element)
-        end
+    context "selenium implementation" 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"
+      end
 
-        it "should call a block on the element method when present" do
-          block_page_object.heading3_element.should == "h3"
-        end
+      it "should retrieve the element from the page" do
+        selenium_browser.should_receive(:find_element).and_return(selenium_browser)
+        element = selenium_page_object.heading5_element
+        element.should be_instance_of PageObject::Elements::Heading
       end
+    end
+  end
 
-      context "watir implementation" do
-        it "should retrieve the text from the h3" do
-          watir_browser.should_receive(:h3).and_return(watir_browser)
-          watir_browser.should_receive(:text).and_return("value")
-          watir_page_object.heading3.should == "value"        
-        end
+  describe "h6 accessors" do
+    context "when called on a page object" do
+      it "should generate accessor methods" do
+        watir_page_object.should respond_to(:heading6)
+        watir_page_object.should respond_to(:heading6_element)
+      end
 
-        it "should retrieve the element from the page" do
-          watir_browser.should_receive(:h3).and_return(watir_browser)
-          element = watir_page_object.heading3_element
-          element.should be_instance_of PageObject::Elements::Heading
-        end
+      it "should call a block on the element method when present" do
+        block_page_object.heading6_element.should == "h6"
       end
+    end
 
-      context "selenium implementation" 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"
-        end
+    context "watir implementation" do
+      it "should retrieve the text from the h6" do
+        watir_browser.should_receive(:h6).and_return(watir_browser)
+        watir_browser.should_receive(:text).and_return("value")
+        watir_page_object.heading6.should == "value"        
+      end
+
+      it "should retrieve the element from the page" do
+        watir_browser.should_receive(:h6).and_return(watir_browser)
+        element = watir_page_object.heading6_element
+        element.should be_instance_of PageObject::Elements::Heading
+      end
+    end
 
-        it "should retrieve the element from the page" do
-          selenium_browser.should_receive(:find_element).and_return(selenium_browser)
-          element = selenium_page_object.heading3_element
-          element.should be_instance_of PageObject::Elements::Heading
-        end
+    context "selenium implementation" 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"
+      end
+
+      it "should retrieve the element from the page" do
+        selenium_browser.should_receive(:find_element).and_return(selenium_browser)
+        element = selenium_page_object.heading6_element
+        element.should be_instance_of PageObject::Elements::Heading
+      end
+    end
+  end
+
+
+  describe "p accessors" do
+    context "when called on a page object" do
+      it "should generate accessor methods" do
+        watir_page_object.should respond_to(:first_para)
+        watir_page_object.should respond_to(:first_para_element)
+      end
+
+      it "should call a block on the element method when present" do
+        block_page_object.first_para_element.should == "p"
+      end
+    end
+
+    context "watir implementation" do
+      it "should retrieve the text from the p" do
+        watir_browser.should_receive(:p).and_return(watir_browser)
+        watir_browser.should_receive(:text).and_return("value")
+        watir_page_object.first_para.should == "value"        
+      end
+
+      it "should retrieve the element from the page" do
+        watir_browser.should_receive(:p).and_return(watir_browser)
+        element = watir_page_object.first_para_element
+        element.should be_instance_of PageObject::Elements::Paragraph
+      end
+    end
+
+    context "selenium implementation" 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"
+      end
+
+      it "should retrieve the element from the page" do
+        selenium_browser.should_receive(:find_element).and_return(selenium_browser)
+        element = selenium_page_object.first_para_element
+        element.should be_instance_of PageObject::Elements::Paragraph
       end
     end
   end

data/spec/page-object/element_locators_spec.rb

@@ -128,4 +128,28 @@ describe PageObject::ElementLocators do
     element = watir_page_object.h3_element(:id => 'blah')
     element.should be_instance_of PageObject::Elements::Heading
   end
+
+  it "should find a h4 element" do
+    watir_browser.should_receive(:h4).with(:id => 'blah').and_return(watir_browser)
+    element = watir_page_object.h4_element(:id => 'blah')
+    element.should be_instance_of PageObject::Elements::Heading
+  end
+
+  it "should find a h5 element" do
+    watir_browser.should_receive(:h5).with(:id => 'blah').and_return(watir_browser)
+    element = watir_page_object.h5_element(:id => 'blah')
+    element.should be_instance_of PageObject::Elements::Heading
+  end
+
+  it "should find a h6 element" do
+    watir_browser.should_receive(:h6).with(:id => 'blah').and_return(watir_browser)
+    element = watir_page_object.h6_element(:id => 'blah')
+    element.should be_instance_of PageObject::Elements::Heading
+  end
+
+  it "should find a paragraph element" do
+    watir_browser.should_receive(:p).with(:id => 'blah').and_return(watir_browser)
+    element = watir_page_object.paragraph_element(:id => 'blah')
+    element.should be_instance_of PageObject::Elements::Paragraph
+  end
 end

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

@@ -2,8 +2,7 @@ require 'spec_helper'
 require 'page-object/elements'
 
 
-describe PageObject::Elements::Element do
-  let(:element) { PageObject::Elements::Element }
+describe "Element class methods" do
 
   context "when handling unknown requests" do
     it "should delegate to the driver element" do
@@ -18,7 +17,7 @@ describe PageObject::Elements::Element do
     it "should build xpath when finding elements by name where not supported" do
       ['table', 'span', 'div', 'td', 'li', 'ol', 'ul'].each do |tag|
         how = {:tag_name => tag, :name => 'blah'}
-        result = element.watir_identifier_for how
+        result = PageObject::Elements::Element.watir_identifier_for how
         result[:xpath].should == ".//#{tag}[@name='blah']"
       end
     end
@@ -36,7 +35,7 @@ describe PageObject::Elements::Element do
     it "should build xpath when index is provided for basic elements" do
       all_basic_elements.each do |tag|
         identifier = {:tag_name => tag, :index => 1}
-        how, what = element.selenium_identifier_for identifier
+        how, what = PageObject::Elements::Element.selenium_identifier_for identifier
         how.should == :xpath
         what.should == ".//#{tag}[2]"
       end
@@ -45,7 +44,7 @@ describe PageObject::Elements::Element do
     it "should should build xpath when index is provided for input elements" do
       all_input_elements.each do |tag|
         identifier = {:tag_name => 'input', :type => tag, :index => 1}
-        how, what = element.selenium_identifier_for identifier
+        how, what = PageObject::Elements::Element.selenium_identifier_for identifier
         how.should == :xpath
         what.should == ".//input[@type='#{tag}'][2]"
       end
@@ -54,7 +53,7 @@ describe PageObject::Elements::Element do
     it "should build xpath when locating basic elements by name and index" do
       all_basic_elements.each do |tag|
         identifier = {:tag_name => tag, :name => 'blah', :index => 0}
-        how, what = element.selenium_identifier_for identifier
+        how, what = PageObject::Elements::Element.selenium_identifier_for identifier
         how.should == :xpath
         what.should == ".//#{tag}[@name='blah'][1]"
       end
@@ -63,7 +62,7 @@ describe PageObject::Elements::Element do
     it "should build xpath when locating input elements by name and index" do
       all_input_elements.each do |type|
         identifier = {:tag_name => 'input', :type => "#{type}", :name => 'blah', :index => 0}
-        how, what = element.selenium_identifier_for identifier
+        how, what = PageObject::Elements::Element.selenium_identifier_for identifier
         how.should == :xpath
         what.should == ".//input[@type='#{type}' and @name='blah'][1]"
       end
@@ -72,7 +71,7 @@ describe PageObject::Elements::Element do
     it "should build xpath when locating basic elements by name and class" do
       all_basic_elements.each do |tag|
         identifier = {:tag_name => tag, :name => 'foo', :class => 'bar'}
-        how, what = element.selenium_identifier_for identifier
+        how, what = PageObject::Elements::Element.selenium_identifier_for identifier
         how.should == :xpath
         what.should == ".//#{tag}[@name='foo' and @class='bar']"
       end
@@ -81,249 +80,9 @@ describe PageObject::Elements::Element do
     it "should build xpath when locating input elements by name and class" do
       all_input_elements.each do |type|
         identifier = {:tag_name => 'input', :type => "#{type}", :name => 'foo', :class => 'bar'}
-        how, what = element.selenium_identifier_for identifier
+        how, what = PageObject::Elements::Element.selenium_identifier_for identifier
         what.should == ".//input[@type='#{type}' and @name='foo' and @class='bar']"
       end
     end
-  end
-
-  context "when using Watir" do
-    let(:watir_driver) { double('watir_element_driver') }
-    let(:watir_element) { PageObject::Elements::Element.new(watir_driver, :platform => :watir_webdriver) }
-
-    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
-
-  context "when using Selenium" do
-    let(:selenium_driver) { double('selenium') }
-    let(:selenium_element) { PageObject::Elements::Element.new(selenium_driver, :platform => :selenium_webdriver) }
-
-    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')
-      Object::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')
-      Object::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')
-      Object::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')
-      Object::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')
-      Object::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')
-      Object::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')
-      Object::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
+  end  
 end