page-object 0.2 → 0.2.1

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

@@ -1,34 +1,34 @@
-require 'spec_helper'
-require 'page-object/elements'
-
-describe PageObject::Elements::Button do
-  let(:button) { PageObject::Elements::Button }
-  
-  context "when mapping how to find an element" do
-    it "should map watir types to same" do
-      [:class, :id, :index, :name, :xpath].each do |t|
-        identifier = button.watir_identifier_for t => 'value'
-        identifier.keys.first.should == t
-      end
-    end
-
-    it "should map selenium types to same" do
-      [:class, :id, :index, :name, :xpath].each do |t|
-        key, value = button.selenium_identifier_for t => 'value'
-        key.should == t
-      end
-    end
-  end
-
-  describe "interface" do
-    let(:button_element) { double('button_element') }
-    
-    context "for selenium" do
-      it "should return error when asked for its' text" do
-        button = PageObject::Elements::Button.new(button_element, :platform => :selenium)
-        lambda {button.text}.should raise_error
-      end      
-    end
-  end
-  
+require 'spec_helper'
+require 'page-object/elements'
+
+describe PageObject::Elements::Button do
+  let(:button) { PageObject::Elements::Button }
+
+  context "when mapping how to find an element" do
+    it "should map watir types to same" do
+      [:class, :id, :index, :name, :xpath].each do |t|
+        identifier = button.watir_identifier_for t => 'value'
+        identifier.keys.first.should == t
+      end
+    end
+
+    it "should map selenium types to same" do
+      [:class, :id, :index, :name, :xpath].each do |t|
+        key, value = button.selenium_identifier_for t => 'value'
+        key.should == t
+      end
+    end
+  end
+
+  describe "interface" do
+    let(:button_element) { double('button_element') }
+
+    context "for selenium" do
+      it "should return error when asked for its' text" do
+        button = PageObject::Elements::Button.new(button_element, :platform => :selenium)
+        lambda { button.text }.should raise_error
+      end
+    end
+  end
+
 end

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

@@ -3,7 +3,7 @@ require 'page-object/elements'
 
 describe PageObject::Elements::CheckBox do
   let(:checkbox) { PageObject::Elements::CheckBox }
-  
+
   describe "when mapping how to find an element" do
     it "should map watir types to same" do
       [:class, :id, :index, :name, :xpath].each do |t|

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

@@ -3,17 +3,17 @@ require 'page-object/elements'
 
 describe PageObject::Elements::Div do
   let(:div) { PageObject::Elements::Div }
-  
+
   describe "when mapping how to find an element" do
     it "should map watir types to same" do
-      [:class, :id, :index, :xpath].each do |t|
+      [:class, :id, :text, :index, :xpath].each do |t|
         identifier = div.watir_identifier_for t => 'value'
         identifier.keys.first.should == t
       end
     end
 
     it "should map selenium types to same" do
-      [:class, :id, :index, :name, :xpath].each do |t|
+      [:class, :id, :text, :index, :name, :xpath].each do |t|
         key, value = div.selenium_identifier_for t => 'value'
         key.should == t
       end

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

@@ -7,7 +7,7 @@ describe PageObject::Elements::Element do
   let(:selenium_driver) { double('selenium') }
   let(:watir_element) { PageObject::Elements::Element.new(watir_driver, :platform => :watir) }
   let(:selenium_element) { PageObject::Elements::Element.new(selenium_driver, :platform => :selenium) }
-  let(:element) {PageObject::Elements::Element}
+  let(:element) { PageObject::Elements::Element }
 
   context "when building the identifiers for Watir" do
     it "should build xpath when finding elements by name where not supported" do
@@ -18,16 +18,16 @@ describe PageObject::Elements::Element do
       end
     end
   end
-  
+
   context "when building the identifiers for Selenium" do
     def all_basic_elements
       ['textarea', 'select', 'a', 'div', 'span', 'table', 'td', 'img', 'form', 'li', 'ul', 'ol']
     end
-    
+
     def all_input_elements
       ['text', 'hidden', 'checkbox', 'radio', 'submit']
     end
-    
+
     it "should build xpath when index is provided for basic elements" do
       all_basic_elements.each do |tag|
         identifier = {:tag_name => tag, :index => 1}
@@ -36,7 +36,7 @@ describe PageObject::Elements::Element do
         what.should == ".//#{tag}[2]"
       end
     end
-    
+
     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}
@@ -45,7 +45,7 @@ describe PageObject::Elements::Element do
         what.should == ".//input[@type='#{tag}'][2]"
       end
     end
-    
+
     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}
@@ -54,7 +54,7 @@ describe PageObject::Elements::Element do
         what.should == ".//#{tag}[@name='blah'][1]"
       end
     end
-    
+
     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}
@@ -63,14 +63,14 @@ describe PageObject::Elements::Element do
         what.should == ".//input[@type='#{type}' and @name='blah'][1]"
       end
     end
-    
+
     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.should == :xpath
         what.should == ".//#{tag}[@name='foo' and @class='bar']"
-      end      
+      end
     end
 
     it "should build xpath when locating input elements by name and class" do
@@ -78,7 +78,7 @@ describe PageObject::Elements::Element do
         identifier = {:tag_name => 'input', :type => "#{type}", :name => 'foo', :class => 'bar'}
         how, what = element.selenium_identifier_for identifier
         what.should == ".//input[@type='#{type}' and @name='foo' and @class='bar']"
-      end      
+      end
     end
   end
 
@@ -87,118 +87,123 @@ describe PageObject::Elements::Element 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 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 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 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 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
   end
-  
+
   context "when using Selenium" do
     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      
+      selenium_element.exists?.should == true
     end
-    
+
     it "should know when it does not exist" do
       selenium_element = PageObject::Elements::Element.new(nil, :platform => :selenium)
       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
@@ -206,30 +211,35 @@ describe PageObject::Elements::Element do
 
     it "should be able to block until it is present" do
       wait = double('wait')
-      Selenium::WebDriver::Wait.should_receive(:new).and_return(wait)
+      Object::Selenium::WebDriver::Wait.should_receive(:new).and_return(wait)
       wait.should_receive(:until)
       selenium_element.when_present(10)
     end
-    
+
     it "should be able to block until it is visible" do
       wait = double('wait')
-      Selenium::WebDriver::Wait.should_receive(:new).and_return(wait)
+      Object::Selenium::WebDriver::Wait.should_receive(:new).and_return(wait)
       wait.should_receive(:until)
       selenium_element.when_visible(10)
     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)
+      Object::Selenium::WebDriver::Wait.should_receive(:new).and_return(wait)
       wait.should_receive(:until)
       selenium_element.when_not_visible(10)
     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)
+      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
   end
 end

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

@@ -4,7 +4,7 @@ require 'page-object/elements'
 describe PageObject::Elements::Form do
   describe "interface" do
     let(:form_element) { double('form_element') }
-    
+
     context "for watir" do
       it "should submit a form" do
         form = PageObject::Elements::Form.new(form_element, :platform => :watir)
@@ -12,13 +12,13 @@ describe PageObject::Elements::Form do
         form.submit
       end
     end
-    
+
     context "for selenium" do
       it "should submit a form" do
         form = PageObject::Elements::Form.new(form_element, :platform => :selenium)
         form_element.should_receive(:submit)
         form.submit
-      end      
+      end
     end
   end
 end

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

@@ -3,7 +3,7 @@ require 'page-object/elements'
 
 describe PageObject::Elements::HiddenField do
   let(:hiddenfield) { PageObject::Elements::HiddenField }
-  
+
   describe "when mapping how to find an element" do
     it "should map watir types to same" do
       [:class, :id, :index, :name, :tag_name, :text, :xpath].each do |t|
@@ -16,14 +16,14 @@ describe PageObject::Elements::HiddenField do
       identifier = hiddenfield.watir_identifier_for :css => 'value'
       identifier.keys.first.should == :tag_name
     end
-    
+
     it "should map selenium types to same" do
       [:class, :css, :id, :name, :xpath, :index].each do |t|
         key, value = hiddenfield.selenium_identifier_for t => 'value'
         key.should == t
       end
     end
-    
+
     it "should map watir types to selenium" do
       key, value = hiddenfield.selenium_identifier_for :tag_name => 'value'
       key.should == :css

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

@@ -3,7 +3,7 @@ require 'page-object/elements'
 
 describe PageObject::Elements::Image do
   let(:image) { PageObject::Elements::Image }
-  
+
   describe "when mapping how to find an element" do
     it "should map watir types to same" do
       [:class, :id, :index, :name, :xpath].each do |t|
@@ -19,28 +19,28 @@ describe PageObject::Elements::Image do
       end
     end
   end
-  
+
   describe "interface" do
     let(:image_element) { double('image_element') }
-    
+
     before(:each) do
       image_element.stub(:size).and_return(image_element)
     end
-    
+
     context "for watir" do
       it "should know the images width" do
         image = PageObject::Elements::Image.new(image_element, :platform => :watir)
         image_element.should_receive(:width).and_return(100)
         image.width.should == 100
       end
-      
+
       it "should know the images height" do
         image = PageObject::Elements::Image.new(image_element, :platform => :watir)
         image_element.should_receive(:height).and_return(120)
         image.height.should == 120
       end
     end
-    
+
     context "for selenium" do
       it "should know the images width" do
         dim = double('dimension')
@@ -49,7 +49,7 @@ describe PageObject::Elements::Image do
         dim.should_receive(:width).and_return(100)
         image.width.should == 100
       end
-      
+
       it "should know the images height" do
         dim = double('dimension')
         image = PageObject::Elements::Image.new(image_element, :platform => :selenium)