page-object 1.0.2 → 1.0.3

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

@@ -8,21 +8,21 @@ describe PageObject::Elements::HiddenField do
     it "should map watir types to same" do
       [:class, :id, :index, :name, :text, :xpath, :value].each do |t|
         identifier = hiddenfield.watir_identifier_for t => 'value'
-        identifier.keys.first.should == t
+        expect(identifier.keys.first).to eql t
       end
     end
 
     it "should map selenium types to same" do
       [:class, :id, :name, :xpath, :index, :value].each do |t|
         key, value = hiddenfield.selenium_identifier_for t => 'value'
-        key.should == t
+        expect(key).to eql t
       end
     end
   end
 
   describe "interface" do
     it "should register with type :hidden" do
-      ::PageObject::Elements.element_class_for(:input, :hidden).should == ::PageObject::Elements::HiddenField
+      expect(::PageObject::Elements.element_class_for(:input, :hidden)).to eql ::PageObject::Elements::HiddenField
     end
   end
 end

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

@@ -8,14 +8,14 @@ describe PageObject::Elements::Image do
     it "should map watir types to same" do
       [:class, :id, :index, :name, :xpath, :alt, :src].each do |t|
         identifier = image.watir_identifier_for t => 'value'
-        identifier.keys.first.should == t
+        expect(identifier.keys.first).to eql t
       end
     end
 
     it "should map selenium types to same" do
       [:class, :id, :index, :name, :xpath, :alt, :src].each do |t|
         key, value = image.selenium_identifier_for t => 'value'
-        key.should == t
+        expect(key).to eql t
       end
     end
   end
@@ -24,24 +24,24 @@ describe PageObject::Elements::Image do
     let(:image_element) { double('image_element') }
 
     before(:each) do
-      image_element.stub(:size).and_return(image_element)
+      allow(image_element).to receive(:size).and_return(image_element)
     end
 
     it "should register with tag_name :img" do
-      ::PageObject::Elements.element_class_for(:img).should == ::PageObject::Elements::Image
+      expect(::PageObject::Elements.element_class_for(:img)).to eql ::PageObject::Elements::Image
     end
 
     context "for watir" do
       it "should know the images width" do
         image = PageObject::Elements::Image.new(image_element, :platform => :watir_webdriver)
-        image_element.should_receive(:width).and_return(100)
-        image.width.should == 100
+        expect(image_element).to receive(:width).and_return(100)
+        expect(image.width).to eql 100
       end
 
       it "should know the images height" do
         image = PageObject::Elements::Image.new(image_element, :platform => :watir_webdriver)
-        image_element.should_receive(:height).and_return(120)
-        image.height.should == 120
+        expect(image_element).to receive(:height).and_return(120)
+        expect(image.height).to eql 120
       end
     end
 
@@ -49,17 +49,17 @@ describe PageObject::Elements::Image do
       it "should know the images width" do
         dim = double('dimension')
         image = PageObject::Elements::Image.new(image_element, :platform => :selenium_webdriver)
-        image_element.should_receive(:size).and_return(dim)
-        dim.should_receive(:width).and_return(100)
-        image.width.should == 100
+        expect(image_element).to receive(:size).and_return(dim)
+        expect(dim).to receive(:width).and_return(100)
+        expect(image.width).to eql 100
       end
 
       it "should know the images height" do
         dim = double('dimension')
         image = PageObject::Elements::Image.new(image_element, :platform => :selenium_webdriver)
-        image_element.should_receive(:size).and_return(dim)
-        dim.should_receive(:height).and_return(120)
-        image.height.should == 120
+        expect(image_element).to receive(:size).and_return(dim)
+        expect(dim).to receive(:height).and_return(120)
+        expect(image.height).to eql 120
       end
     end
   end

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

@@ -8,20 +8,20 @@ describe PageObject::Elements::Label do
     it "should map watir types to same" do
       [:class, :id, :text, :index, :xpath].each do |t|
         identifier = label.watir_identifier_for t => 'value'
-        identifier.keys.first.should == t
+        expect(identifier.keys.first).to eql t
       end
     end
 
     it "should map selenium types to same" do
       [:class, :id, :text, :index, :xpath].each do |t|
         key, value = label.selenium_identifier_for t => 'value'
-        key.should == t
+        expect(key).to eql t
       end
     end
 
     describe "interface" do
       it "should register with tag :label" do
-        ::PageObject::Elements.element_class_for(:label).should == ::PageObject::Elements::Label
+        expect(::PageObject::Elements.element_class_for(:label)).to eql ::PageObject::Elements::Label
       end
     end
   end

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

@@ -8,27 +8,27 @@ describe PageObject::Elements::Link do
     it "should map watir types to same" do
       [:class, :href, :id, :index, :name, :text, :xpath, :css, :title].each do |t|
         identifier = link.watir_identifier_for t => 'value'
-        identifier.keys.first.should == t
+        expect(identifier.keys.first).to eql t
       end
     end
 
     it "should map selenium types to watir" do
       [:link, :link_text].each do |t|
         identifier = link.watir_identifier_for t => 'value'
-        identifier.keys.first.should == :text
+        expect(identifier.keys.first).to eql :text
       end
     end
 
     it "should map selenium types to same" do
       [:class, :id, :link, :link_text, :name, :xpath, :index, :css, :title].each do |t|
         key, value = link.selenium_identifier_for t => 'value'
-        key.should == t
+        expect(key).to eql t
       end
     end
 
     it "should map watir types to selenium" do
       key, value = link.selenium_identifier_for :text => 'value'
-      key.should == :link_text
+      expect(key).to eql :link_text
     end
   end
 
@@ -36,13 +36,13 @@ describe PageObject::Elements::Link do
     let(:link_element) { double('link_element') }
 
     it "should register with tag :a" do
-      ::PageObject::Elements.element_class_for(:a).should == ::PageObject::Elements::Link
+      expect(::PageObject::Elements.element_class_for(:a)).to eql ::PageObject::Elements::Link
     end
 
     context "for selenium" do
       it "should return error when asked for its' value" do
         link = PageObject::Elements::Link.new(link_element, :platform => :selenium_webdriver)
-        lambda { link.value }.should raise_error
+        expect(lambda { link.value }).to raise_error
       end
     end
   end

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

@@ -8,21 +8,22 @@ describe PageObject::Elements::ListItem do
     it "should map watir types to same" do
       [:class, :id, :index, :text, :xpath].each do |t|
         identifier = list_item.watir_identifier_for t => 'value'
-        identifier.keys.first.should == t
+        expect(identifier.keys.first).to eql t
       end
     end
 
     it "should map selenium types to same" do
       [:class, :id, :index, :name, :text, :xpath].each do |t|
         key, value = list_item.selenium_identifier_for t => 'value'
-        key.should == t
+        expect(key).to eql t
       end
     end
 
     describe "interface" do
       it "should register as tag_name :li" do
-        ::PageObject::Elements.element_class_for(:li).should == ::PageObject::Elements::ListItem
+        expect(::PageObject::Elements.element_class_for(:li)).to eql ::PageObject::Elements::ListItem
       end
     end
   end
 end
+

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

@@ -10,117 +10,117 @@ describe "Element with nested elements" do
     end
     
     it "should find nested links" do
-      @watir_driver.should_receive(:link).with(:id => 'blah').and_return(@watir_driver)
+      expect(@watir_driver).to 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)
+      expect(@watir_driver).to 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)
+      expect(@watir_driver).to 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)
+      expect(@watir_driver).to 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)
+      expect(@watir_driver).to 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)
+      expect(@watir_driver).to 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)
+      expect(@watir_driver).to 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)
+      expect(@watir_driver).to 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)
+      expect(@watir_driver).to 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)
+      expect(@watir_driver).to 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)
+      expect(@watir_driver).to 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)
+      expect(@watir_driver).to 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)
+      expect(@watir_driver).to 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)
+      expect(@watir_driver).to 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)
+      expect(@watir_driver).to 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)
+      expect(@watir_driver).to 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)
+      expect(@watir_driver).to 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)
+      expect(@watir_driver).to 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)
+      expect(@watir_driver).to 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)
+      expect(@watir_driver).to 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)
+      expect(@watir_driver).to 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)
+      expect(@watir_driver).to 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)
+      expect(@watir_driver).to receive(:h6).and_return(@watir_driver)
       @watir_element.h6_element
     end
   end
@@ -132,122 +132,122 @@ describe "Element with nested elements" do
     end
 
     it "should find nested links" do
-      @selenium_driver.should_receive(:find_element).with(:id, 'blah').and_return(@selenium_driver)
+      expect(@selenium_driver).to 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)
+      expect(@selenium_driver).to 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)
+      expect(@selenium_driver).to 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)
+      expect(@selenium_driver).to 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)
+      expect(@selenium_driver).to 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)
+      expect(@selenium_driver).to 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)
+      expect(@selenium_driver).to 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)
+      expect(@selenium_driver).to 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)
+      expect(@selenium_driver).to 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)
+      expect(@selenium_driver).to 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)
+      expect(@selenium_driver).to 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)
+      expect(@selenium_driver).to 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)
+      expect(@selenium_driver).to 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)
+      expect(@selenium_driver).to 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)
+      expect(@selenium_driver).to 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)
+      expect(@selenium_driver).to 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)
+      expect(@selenium_driver).to 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)
+      expect(@selenium_driver).to 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)
+      expect(@selenium_driver).to 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)
+      expect(@selenium_driver).to 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)
+      expect(@selenium_driver).to 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)
+      expect(@selenium_driver).to 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)
+      expect(@selenium_driver).to 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)
+      expect(@selenium_driver).to receive(:find_element).and_return(@selenium_driver)
       @selenium_element.paragraph_element
     end
   end