page-object 1.0.2 → 1.0.3

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

@@ -8,14 +8,14 @@ describe PageObject::Elements::Area do
     it "should map watir types to same" do
       [:class, :id, :index, :name, :xpath].each do |t|
         identifier = area.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].each do |t|
         key, value = area.selenium_identifier_for t => 'value'
-        key.should == t
+        expect(key).to eql t
       end
     end
   end
@@ -27,18 +27,18 @@ describe PageObject::Elements::Area do
       let(:selenium_area) { PageObject::Elements::Area.new(area_element, :platform => :selenium_webdriver) }
       
       it "should know its coords" do
-        area_element.should_receive(:attribute).with(:coords).and_return("1,2,3,4")
-        selenium_area.coords.should == "1,2,3,4"
+        expect(area_element).to receive(:attribute).with(:coords).and_return("1,2,3,4")
+        expect(selenium_area.coords).to eql "1,2,3,4"
       end
 
       it "should know its shape" do
-        area_element.should_receive(:attribute).with(:shape).and_return('circle')
-        selenium_area.shape.should == 'circle'
+        expect(area_element).to receive(:attribute).with(:shape).and_return('circle')
+        expect(selenium_area.shape).to eql 'circle'
       end
 
       it "should know its href" do
-        area_element.should_receive(:attribute).with(:href).and_return('twitter.com')
-        selenium_area.href.should == 'twitter.com'
+        expect(area_element).to receive(:attribute).with(:href).and_return('twitter.com')
+        expect(selenium_area.href).to eql 'twitter.com'
       end
     end
   end

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

@@ -0,0 +1,29 @@
+require 'spec_helper'
+require 'page-object/elements'
+
+describe PageObject::Elements::Bold do
+  let(:bold) { PageObject::Elements::Bold }
+
+  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|
+        identifier = bold.watir_identifier_for t => 'value'
+        expect(identifier.keys.first).to eql t
+      end
+    end
+
+    it "should map selenium types to same" do
+      [:class, :id, :index, :name, :xpath].each do |t|
+        key, value = bold.selenium_identifier_for t => 'value'
+        expect(key).to eql t
+      end
+    end
+  end
+
+  describe "interface" do
+
+    it "should register with tag :b" do
+      expect(::PageObject::Elements.element_class_for(:b)).to eql ::PageObject::Elements::Bold
+    end
+  end
+end

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

@@ -8,14 +8,14 @@ describe PageObject::Elements::Button do
     it "should map watir types to same" do
       [:class, :id, :index, :name, :value, :xpath, :src, :alt, :css].each do |t|
         identifier = button.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, :value, :xpath, :src, :alt, :css].each do |t|
         key, value = button.selenium_identifier_for t => 'value'
-        key.should == t
+        expect(key).to eql t
       end
     end
   end
@@ -24,25 +24,25 @@ describe PageObject::Elements::Button do
     let(:button_element) { double('button_element') }
 
     it "should register with type :submit" do
-      ::PageObject::Elements.element_class_for(:input, :submit).should == ::PageObject::Elements::Button
+      expect(::PageObject::Elements.element_class_for(:input, :submit)).to eql ::PageObject::Elements::Button
     end
 
     it "should register with type :image" do
-      ::PageObject::Elements.element_class_for(:input, :image).should == ::PageObject::Elements::Button
+      expect(::PageObject::Elements.element_class_for(:input, :image)).to eql ::PageObject::Elements::Button
     end
 
     it "should register with type :button" do
-      ::PageObject::Elements.element_class_for(:input, :button).should == ::PageObject::Elements::Button
+      expect(::PageObject::Elements.element_class_for(:input, :button)).to eql ::PageObject::Elements::Button
     end
 
     it "should retisger with type :reset" do
-      ::PageObject::Elements.element_class_for(:input, :reset).should == ::PageObject::Elements::Button
+      expect(::PageObject::Elements.element_class_for(:input, :reset)).to eql ::PageObject::Elements::Button
     end
 
     context "for selenium" do
       it "should return error when asked for its' text" do
         button = PageObject::Elements::Button.new(button_element, :platform => :selenium_webdriver)
-        lambda { button.text }.should raise_error
+        expect(lambda { button.text }).to raise_error
       end
     end
   end

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

@@ -8,14 +8,14 @@ describe PageObject::Elements::Canvas do
     it "should map watir types to same" do
       [:class, :id, :index, :name, :xpath].each do |t|
         identifier = area.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].each do |t|
         key, value = area.selenium_identifier_for t => 'value'
-        key.should == t
+        expect(key).to eql t
       end
     end
   end
@@ -27,13 +27,13 @@ describe PageObject::Elements::Canvas do
       let(:selenium_canvas) { PageObject::Elements::Canvas.new(canvas_element, :platform => :selenium_webdriver) }
 
       it "should know its width" do
-        canvas_element.should_receive(:attribute).with(:width).and_return("400")
-        selenium_canvas.width.should == 400
+        expect(canvas_element).to receive(:attribute).with(:width).and_return("400")
+        expect(selenium_canvas.width).to eql 400
       end
 
       it "should know its height" do
-        canvas_element.should_receive(:attribute).with(:height).and_return("100")
-        selenium_canvas.height.should == 100
+        expect(canvas_element).to receive(:attribute).with(:height).and_return("100")
+        expect(selenium_canvas.height).to eql 100
       end
     end
   end

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

@@ -8,13 +8,13 @@ describe PageObject::Elements::CheckBox do
     it "should map watir types to same" do
       [:class, :id, :index, :name, :xpath, :value].each do |t|
         identifier = checkbox.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 = checkbox.selenium_identifier_for t => 'value'
-        key.should == t
+        expect(key).to eql t
       end
     end
   end
@@ -24,25 +24,25 @@ describe PageObject::Elements::CheckBox do
     let(:selenium_cb) { PageObject::Elements::CheckBox.new(check_box, :platform => :selenium_webdriver) }
 
     it "should register with type :checkbox" do
-      ::PageObject::Elements.element_class_for(:input, :checkbox).should == ::PageObject::Elements::CheckBox
+      expect(::PageObject::Elements.element_class_for(:input, :checkbox)).to eql ::PageObject::Elements::CheckBox
     end
     
     context "for selenium" do
       it "should check" do
-        check_box.should_receive(:click)
-        check_box.should_receive(:selected?).and_return(false)
+        expect(check_box).to receive(:click)
+        expect(check_box).to receive(:selected?).and_return(false)
         selenium_cb.check
       end
 
       it "should uncheck" do
-        check_box.should_receive(:click)
-        check_box.should_receive(:selected?).and_return(true)
+        expect(check_box).to receive(:click)
+        expect(check_box).to receive(:selected?).and_return(true)
         selenium_cb.uncheck
       end
       
       it "should know if it is checked" do
-        check_box.should_receive(:selected?).and_return(true)
-        selenium_cb.should be_checked
+        expect(check_box).to receive(:selected?).and_return(true)
+        expect(selenium_cb).to be_checked
       end
     end
   end

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

@@ -8,20 +8,20 @@ describe PageObject::Elements::Div do
     it "should map watir types to same" do
       [:class, :id, :text, :index, :xpath, :name, :title, :css].each do |t|
         identifier = div.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, :name, :xpath, :title, :css].each do |t|
         key, value = div.selenium_identifier_for t => 'value'
-        key.should == t
+        expect(key).to eql t
       end
     end
 
     describe "interface" do
       it "should register with tag :div" do
-        ::PageObject::Elements.element_class_for(:div).should == ::PageObject::Elements::Div
+        expect(::PageObject::Elements.element_class_for(:div)).to eql ::PageObject::Elements::Div
       end
     end
   end

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

@@ -9,7 +9,7 @@ describe "Element" do
       ['table', 'span', 'div', 'td', 'li', 'ol', 'ul'].each do |tag|
         how = {:tag_name => tag, :name => 'blah'}
         result = PageObject::Elements::Element.watir_identifier_for how
-        result[:xpath].should == ".//#{tag}[@name='blah']"
+        expect(result[:xpath]).to eql ".//#{tag}[@name='blah']"
       end
     end
   end
@@ -27,8 +27,8 @@ describe "Element" do
       all_basic_elements.each do |tag|
         identifier = {:tag_name => tag, :index => 1}
         how, what = PageObject::Elements::Element.selenium_identifier_for identifier
-        how.should == :xpath
-        what.should == "(.//#{tag})[2]"
+        expect(how).to eql :xpath
+        expect(what).to eql "(.//#{tag})[2]"
       end
     end
 
@@ -36,8 +36,8 @@ describe "Element" do
       all_input_elements.each do |tag|
         identifier = {:tag_name => 'input', :type => tag, :index => 1}
         how, what = PageObject::Elements::Element.selenium_identifier_for identifier
-        how.should == :xpath
-        what.should include "(.//input[@type='#{tag}'])[2]"
+        expect(how).to eql :xpath
+        expect(what).to include "(.//input[@type='#{tag}'])[2]"
       end
     end
 
@@ -45,8 +45,8 @@ describe "Element" do
       all_basic_elements.each do |tag|
         identifier = {:tag_name => tag, :name => 'blah', :index => 0}
         how, what = PageObject::Elements::Element.selenium_identifier_for identifier
-        how.should == :xpath
-        what.should == "(.//#{tag}[@name='blah'])[1]"
+        expect(how).to eql :xpath
+        expect(what).to eql "(.//#{tag}[@name='blah'])[1]"
       end
     end
 
@@ -54,8 +54,8 @@ describe "Element" do
       all_input_elements.each do |type|
         identifier = {:tag_name => 'input', :type => "#{type}", :name => 'blah', :index => 0}
         how, what = PageObject::Elements::Element.selenium_identifier_for identifier
-        how.should == :xpath
-        what.should include "(.//input[@type='#{type}' and @name='blah'])[1]"
+        expect(how).to eql :xpath
+        expect(what).to include "(.//input[@type='#{type}' and @name='blah'])[1]"
       end
     end
 
@@ -63,8 +63,8 @@ describe "Element" do
       all_basic_elements.each do |tag|
         identifier = {:tag_name => tag, :class => 'bar', :name => 'foo'}
         how, what = PageObject::Elements::Element.selenium_identifier_for identifier
-        how.should == :xpath
-        what.should == ".//#{tag}[@class='bar' and @name='foo']"
+        expect(how).to eql :xpath
+        expect(what).to eql ".//#{tag}[@class='bar' and @name='foo']"
       end
     end
 
@@ -72,7 +72,7 @@ describe "Element" do
       all_input_elements.each do |type|
         identifier = {:tag_name => 'input', :type => "#{type}", :class => 'bar', :name => 'foo'}
         how, what = PageObject::Elements::Element.selenium_identifier_for identifier
-        what.should include ".//input[@type='#{type}' and @class='bar' and @name='foo']"
+        expect(what).to include ".//input[@type='#{type}' and @class='bar' and @name='foo']"
       end
     end
   end
@@ -82,33 +82,33 @@ describe "Element" do
     let(:element) { PageObject::Elements::Element.new(native, :platform => :watir_webdriver) }
 
     it "should check if native is enabled" do
-      native.should_receive(:enabled?).and_return(true)
-      element.should be_enabled
+      expect(native).to receive(:enabled?).and_return(true)
+      expect(element).to be_enabled
     end
 
     it "should click the native" do
-      native.should_receive(:click)
+      expect(native).to receive(:click)
       element.click
     end
 
     it "should double click the native" do
-      native.should_receive(:double_click)
+      expect(native).to receive(:double_click)
       element.double_click
     end
 
     it "should inspect the native" do
-      native.should_receive(:inspect)
+      expect(native).to receive(:inspect)
       element.inspect
     end
 
     it "should retrieve the native's style" do
-      native.should_receive(:style).with('foo').and_return("cheezy_style")
-      element.style('foo').should == 'cheezy_style'
+      expect(native).to receive(:style).with('foo').and_return("cheezy_style")
+      expect(element.style('foo')).to eql 'cheezy_style'
     end
 
     it "should know if a native is disabled" do
-      native.should_receive(:enabled?).and_return(false)
-      element.should be_disabled
+      expect(native).to receive(:enabled?).and_return(false)
+      expect(element).to be_disabled
     end
   end
 end

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

@@ -9,14 +9,14 @@ describe PageObject::Elements::FileField do
     it "should map watir types to same" do
       [:class, :id, :index, :name, :xpath, :title].each do |t|
         identifier = filefield.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, :title].each do |t|
         key, value = filefield.selenium_identifier_for t => 'value'
-        key.should == t
+        expect(key).to eql t
       end
     end
   end
@@ -25,13 +25,13 @@ describe PageObject::Elements::FileField do
     let(:filefield) { double('file_field') }
 
     it "should register as type :file" do
-      ::PageObject::Elements.element_class_for(:input, :file).should == ::PageObject::Elements::FileField
+      expect(::PageObject::Elements.element_class_for(:input, :file)).to eql ::PageObject::Elements::FileField
     end
     
     context "for selenium" do
       it "should set its' value" do
         selenium_file_field = PageObject::Elements::FileField.new(filefield, :platform => :selenium_webdriver)
-        filefield.should_receive(:send_keys).with('a file')
+        expect(filefield).to receive(:send_keys).with('a file')
         selenium_file_field.value = 'a file'
       end
     end

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

@@ -6,13 +6,13 @@ describe PageObject::Elements::Form do
     let(:form_element) { double('form_element') }
 
     it "should register with tag_name :form" do
-      ::PageObject::Elements.element_class_for(:form).should == ::PageObject::Elements::Form
+      expect(::PageObject::Elements.element_class_for(:form)).to eql ::PageObject::Elements::Form
     end
 
     context "for watir" do
       it "should submit a form" do
         form = PageObject::Elements::Form.new(form_element, :platform => :watir_webdriver)
-        form_element.should_receive(:submit)
+        expect(form_element).to receive(:submit)
         form.submit
       end
     end
@@ -20,7 +20,7 @@ describe PageObject::Elements::Form do
     context "for selenium" do
       it "should submit a form" do
         form = PageObject::Elements::Form.new(form_element, :platform => :selenium_webdriver)
-        form_element.should_receive(:submit)
+        expect(form_element).to receive(:submit)
         form.submit
       end
     end

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

@@ -8,41 +8,41 @@ describe PageObject::Elements::Heading do
     it "should map watir types to same" do
       [:class, :id, :index, :name, :xpath].each do |t|
         identifier = heading.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].each do |t|
         key, value = heading.selenium_identifier_for t => 'value'
-        key.should == t
+        expect(key).to eql t
       end
     end
   end
 
   describe "interface" do
     it "should register with tag :h1" do
-      ::PageObject::Elements.element_class_for(:h1).should == ::PageObject::Elements::Heading
+      expect(::PageObject::Elements.element_class_for(:h1)).to eql ::PageObject::Elements::Heading
     end
 
     it "should register with tag :h2" do
-      ::PageObject::Elements.element_class_for(:h2).should == ::PageObject::Elements::Heading
+      expect(::PageObject::Elements.element_class_for(:h2)).to eql ::PageObject::Elements::Heading
     end
 
     it "should register with tag :h3" do
-      ::PageObject::Elements.element_class_for(:h3).should == ::PageObject::Elements::Heading
+      expect(::PageObject::Elements.element_class_for(:h3)).to eql ::PageObject::Elements::Heading
     end
 
     it "should register with tag :h4" do
-      ::PageObject::Elements.element_class_for(:h4).should == ::PageObject::Elements::Heading
+      expect(::PageObject::Elements.element_class_for(:h4)).to eql ::PageObject::Elements::Heading
     end
 
     it "should register with tag :h5" do
-      ::PageObject::Elements.element_class_for(:h5).should == ::PageObject::Elements::Heading
+      expect(::PageObject::Elements.element_class_for(:h5)).to eql ::PageObject::Elements::Heading
     end
 
     it "should register with tag :h6" do
-      ::PageObject::Elements.element_class_for(:h6).should == ::PageObject::Elements::Heading
+      expect(::PageObject::Elements.element_class_for(:h6)).to eql ::PageObject::Elements::Heading
     end
   end
 end