page-object 1.1.0 → 1.1.1

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

@@ -78,7 +78,8 @@ describe "Element" do
   end
 
   context "interaction with native element" do
-    let(:native) { double('') }
+    let(:wd) { double('') }
+    let(:native) { double(wd: wd) }
     let(:element) { PageObject::Elements::Element.new(native, :platform => :watir_webdriver) }
 
     it "should check if native is enabled" do
@@ -110,5 +111,86 @@ describe "Element" do
       expect(native).to receive(:enabled?).and_return(false)
       expect(element).to be_disabled
     end
+
+    it "should know if a native is visible" do
+      expect(native).to receive(:present?).and_return(false)
+      expect(element.visible?).to eq(false)
+    end
+
+    it "should know if a native exists" do
+      expect(native).to receive(:exists?).and_return(true)
+      expect(element).to exist
+    end
+
+    it "should flash the native" do
+      expect(native).to receive(:flash)
+      element.flash
+    end
+
+    it "should inspect the native's text" do
+      expect(native).to receive(:text).and_return('My value is 42')
+      expect(element.text).to eq('My value is 42')
+    end
+
+    it "should inspect the native's html" do
+      expect(native).to receive(:html).and_return('<p>42</p>')
+      expect(element.html).to eq('<p>42</p>')
+    end
+
+    it "should inspect the native's value" do
+      expect(native).to receive(:html).and_return('42')
+      expect(element.html).to eq('42')
+    end
+
+    it "should inspect the native's tag name" do
+      expect(native).to receive(:attribute_value).and_return('bar')
+      expect(element.attribute('foo')).to eq('bar')
+    end
+
+    it "should fire the native's event" do
+      expect(native).to receive(:fire_event).with('hello')
+      element.fire_event('hello')
+    end
+
+    it "should hover" do
+      expect(native).to receive(:hover)
+      element.hover
+    end
+
+    it "should focus" do
+      expect(native).to receive(:focus)
+      element.focus
+    end
+
+    it "should select the native's text" do
+      expect(native).to receive(:select_text).with('hello')
+      element.select_text('hello')
+    end
+
+    it "should wait until present" do
+      expect(native).to receive(:wait_until_present).with(42)
+      element.wait_until_present(42)
+    end
+
+    it "should send keys" do
+      expect(native).to receive(:send_keys).with('foo bar')
+      element.send_keys('foo bar')
+    end
+
+    it "should clear" do
+      expect(native).to receive(:clear)
+      element.clear
+    end
+
+    it "should inspect the native's id" do
+      expect(native).to receive(:id).and_return('element123')
+      expect(element.id).to eq('element123')
+    end
+
+    it "should inspect the native's id" do
+      expect(wd).to receive(:location_once_scrolled_into_view)
+      expect(native).to receive(:wd).and_return(wd)
+      element.scroll_into_view
+    end
   end
 end

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

@@ -0,0 +1,29 @@
+require 'spec_helper'
+require 'page-object/elements'
+
+describe PageObject::Elements::Italic do
+  let(:italic) { PageObject::Elements::Italic }
+
+  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 = italic.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 = italic.selenium_identifier_for t => 'value'
+        expect(key).to eql t
+      end
+    end
+  end
+
+  describe "interface" do
+
+    it "should register with tag :i" do
+      expect(::PageObject::Elements.element_class_for(:i)).to eql ::PageObject::Elements::Italic
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+require 'spec_helper'
+require 'page-object/elements'
+
+describe PageObject::Elements::Media do
+
+  let(:media) { PageObject::Elements::Media.new(double(''), :platform => :watir_webdriver) }
+
+  it "should return autoplay" do
+    expect(media).to receive(:attribute).with(:autoplay).and_return(true)
+    expect(media.autoplay?).to eq(true)
+  end
+
+  it "should return controls" do
+    expect(media).to receive(:attribute).with(:controls).and_return(true)
+    expect(media.has_controls?).to eq(true)
+  end
+
+  it "should return paused" do
+    expect(media).to receive(:attribute).with(:paused).and_return(true)
+    expect(media.paused?).to eq(true)
+  end
+
+  it "should not return duration when not present" do
+    expect(media).to receive(:attribute).with(:duration).and_return(nil)
+    expect(media.duration).to eq(nil)
+  end
+
+  it "should return duration when present" do
+    expect(media).to receive(:attribute).with(:duration).and_return('1.405')
+    expect(media.duration).to eq(1.405)
+  end
+
+  it "should not return volume when not present" do
+    expect(media).to receive(:attribute).with(:volume).and_return(nil)
+    expect(media.volume).to eq(nil)
+  end
+
+  it "should return volume when present" do
+    expect(media).to receive(:attribute).with(:volume).and_return('3')
+    expect(media.volume).to eq(3)
+  end
+
+  it "should return ended" do
+    expect(media).to receive(:attribute).with(:ended).and_return(true)
+    expect(media.ended?).to eq(true)
+  end
+
+  it "should return seeking" do
+    expect(media).to receive(:attribute).with(:seeking).and_return(true)
+    expect(media.seeking?).to eq(true)
+  end
+
+  it "should return loop" do
+    expect(media).to receive(:attribute).with(:loop).and_return(true)
+    expect(media.loop?).to eq(true)
+  end
+
+  it "should return muted" do
+    expect(media).to receive(:attribute).with(:muted).and_return(true)
+    expect(media.muted?).to eq(true)
+  end
+
+end

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

@@ -30,23 +30,14 @@ describe PageObject::Elements::OrderedList do
     context "for watir" do
       it "should return a list item when indexed" do
         ol = PageObject::Elements::OrderedList.new(ol_element, :platform => :watir_webdriver)
-        allow(ol_element).to receive(:ols).and_return([ol_element])
-        allow(ol_element).to receive(:find_elements).and_return(ol_element)
-        allow(ol_element).to receive(:map).and_return([ol_element])
-        allow(ol_element).to receive(:parent).and_return(ol_element)
-        allow(ol_element).to receive(:element).and_return(ol_element)
-        allow(ol_element).to receive(:==).and_return(true)
+        expect(ol_element).to receive(:find_elements).
+                               and_return([ol_element, ol_element])
         ol[1]
       end
 
       it "should know how many list items it contains" do
         ol = PageObject::Elements::OrderedList.new(ol_element, :platform => :watir_webdriver)
-        allow(ol_element).to receive(:ols).and_return([ol_element])
-        allow(ol_element).to receive(:find_elements).and_return(ol_element)
-        allow(ol_element).to receive(:map).and_return([ol_element])
-        allow(ol_element).to receive(:parent).and_return(ol_element)
-        allow(ol_element).to receive(:element).and_return(ol_element)
-        allow(ol_element).to receive(:==).and_return(true)
+        expect(ol_element).to receive(:find_elements).and_return([ol_element])
         expect(ol.items).to eql 1
       end
 
@@ -63,21 +54,14 @@ describe PageObject::Elements::OrderedList do
     context "for selenium" do
       it "should return a list item when indexed" do
         ol = PageObject::Elements::OrderedList.new(ol_element, :platform => :selenium_webdriver)
-        expect(ol_element).to receive(:find_elements).and_return(ol_element)
-        expect(ol_element).to receive(:map).and_return([ol_element])
-        expect(ol_element).to receive(:parent).and_return(ol_element)
-        expect(ol_element).to receive(:element).and_return(ol_element)
-        expect(ol_element).to receive(:==).and_return(true)
+        expect(ol_element).to receive(:find_elements).
+                               and_return([ol_element, ol_element])
         ol[1]
       end
 
       it "should know how many list items it contains" do
         ol = PageObject::Elements::OrderedList.new(ol_element, :platform => :selenium_webdriver)
-        expect(ol_element).to receive(:find_elements).and_return(ol_element)
-        expect(ol_element).to receive(:map).and_return([ol_element])
-        expect(ol_element).to receive(:parent).and_return(ol_element)
-        expect(ol_element).to receive(:element).and_return(ol_element)
-        expect(ol_element).to receive(:==).and_return(true)
+        expect(ol_element).to receive(:find_elements).and_return([ol_element])
         expect(ol.items).to eql 1
       end
 

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

@@ -174,4 +174,45 @@ describe "Element for Selenium" do
     expect(@selenium_driver).to receive(:location_once_scrolled_into_view)
     @selenium_element.scroll_into_view
   end
+
+  it "should have a location" do
+    expect(@selenium_driver).to receive(:location)
+    @selenium_element.location
+  end
+
+  it "should have a size" do
+    expect(@selenium_driver).to receive(:size)
+    @selenium_element.size
+  end
+
+  it "should have a height" do
+    expect(@selenium_driver).to receive(:size).and_return({'width' => 30, 'height' => 20})
+    expect(@selenium_element.height).to eql 20
+  end
+
+  it "should have a width" do
+    expect(@selenium_driver).to receive(:size).and_return({'width' => 30, 'height' => 20})
+    expect(@selenium_element.width).to eql 30
+  end
+
+  it "should have a centre" do
+    expect(@selenium_driver).to receive(:location).and_return({'y' => 80, 'x' => 40})
+    expect(@selenium_driver).to receive(:size).and_return({'width' => 30, 'height' => 20})
+    expect(@selenium_element.centre).to include(
+      'y' => 90,
+      'x' => 55
+    )
+  end
+
+  it "should have a centre greater than y position" do
+    expect(@selenium_driver).to receive(:location).and_return({'y' => 80, 'x' => 40}).twice
+    expect(@selenium_driver).to receive(:size).and_return({'width' => 30, 'height' => 20})
+    expect(@selenium_element.centre['y']).to be > @selenium_element.location['y']
+  end
+
+  it "should have a centre greater than x position" do
+    expect(@selenium_driver).to receive(:location).and_return({'y' => 80, 'x' => 40}).twice
+    expect(@selenium_driver).to receive(:size).and_return({'width' => 30, 'height' => 20})
+    expect(@selenium_element.centre['x']).to be > @selenium_element.location['x']
+  end
 end

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

@@ -30,23 +30,14 @@ describe PageObject::Elements::UnorderedList do
     context "for watir" do
       it "should return a list item when indexed" do
         ul = PageObject::Elements::UnorderedList.new(ul_element, :platform => :watir_webdriver)
-        allow(ul_element).to receive(:uls).and_return([ul_element])
         allow(ul_element).to receive(:find_elements).and_return(ul_element)
-        allow(ul_element).to receive(:map).and_return([ul_element])
-        allow(ul_element).to receive(:parent).and_return(ul_element)
-        allow(ul_element).to receive(:element).and_return(ul_element)
-        allow(ul_element).to receive(:==).and_return(true)
+        expect(ul_element).to receive(:[])
         ul[1]
       end
 
       it "should know how many items it contains" do
         ul = PageObject::Elements::UnorderedList.new(ul_element, :platform => :watir_webdriver)
-        allow(ul_element).to receive(:uls).and_return([ul_element])
-        allow(ul_element).to receive(:find_elements).and_return(ul_element)
-        allow(ul_element).to receive(:map).and_return([ul_element])
-        allow(ul_element).to receive(:parent).and_return(ul_element)
-        allow(ul_element).to receive(:element).and_return(ul_element)
-        allow(ul_element).to receive(:==).and_return(true)
+        allow(ul_element).to receive(:find_elements).and_return([ul_element])
         expect(ul.items).to eql 1
       end
 
@@ -63,21 +54,13 @@ describe PageObject::Elements::UnorderedList do
     context "for selenium" do
       it "should return a list item when indexed" do
         ul = PageObject::Elements::UnorderedList.new(ul_element, :platform => :selenium_webdriver)
-        expect(ul_element).to receive(:find_elements).and_return(ul_element)
-        expect(ul_element).to receive(:map).and_return([ul_element])
-        expect(ul_element).to receive(:parent).and_return(ul_element)
-        expect(ul_element).to receive(:element).and_return(ul_element)
-        expect(ul_element).to receive(:==).and_return(true)
+        expect(ul_element).to receive(:find_elements).and_return([ul_element, ul_element])
         ul[1]
       end
 
       it "should know how many items it contains" do
         ul = PageObject::Elements::UnorderedList.new(ul_element, :platform => :selenium_webdriver)
-        expect(ul_element).to receive(:find_elements).and_return(ul_element)
-        expect(ul_element).to receive(:map).and_return([ul_element])
-        expect(ul_element).to receive(:parent).and_return(ul_element)
-        expect(ul_element).to receive(:element).and_return(ul_element)
-        expect(ul_element).to receive(:==).and_return(true)
+        expect(ul_element).to receive(:find_elements).and_return([ul_element])
         expect(ul.items).to eql 1
       end
 

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

@@ -0,0 +1,27 @@
+require 'spec_helper'
+require 'page-object/elements'
+
+describe PageObject::Elements::ListItem do
+
+  let(:video) { PageObject::Elements::Video.new(double(''), :platform => :watir_webdriver) }
+
+  it "should return height when present" do
+    expect(video).to receive(:attribute).with(:height).and_return("20")
+    expect(video.height).to eq(20)
+  end
+
+  it "should not return height when not present" do
+    expect(video).to receive(:attribute).with(:height).and_return(nil)
+    expect(video.height).to eq(nil)
+  end
+
+  it "should return width when present" do
+    expect(video).to receive(:attribute).with(:width).and_return("20")
+    expect(video.width).to eq(20)
+  end
+
+  it "should not return width when not present" do
+    expect(video).to receive(:attribute).with(:width).and_return(nil)
+    expect(video.width).to eq(nil)
+  end
+end

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

@@ -142,4 +142,52 @@ describe "Element for Watir" do
     expect(watir_driver).to receive(:location_once_scrolled_into_view)
     watir_element.scroll_into_view
   end
+
+  it "should know its location" do
+    allow(watir_driver).to receive(:wd).and_return(watir_driver)
+    expect(watir_driver).to receive(:location)
+    watir_element.location
+  end
+
+  it "should know its size" do
+    allow(watir_driver).to receive(:wd).and_return(watir_driver)
+    expect(watir_driver).to receive(:size)
+    watir_element.size
+  end
+
+  it "should have a height" do
+    allow(watir_driver).to receive(:wd).and_return(watir_driver)
+    expect(watir_driver).to receive(:size).and_return({'width' => 30, 'height' => 20})
+    expect(watir_element.height).to eql 20
+  end
+
+  it "should have a width" do
+    allow(watir_driver).to receive(:wd).and_return(watir_driver)
+    expect(watir_driver).to receive(:size).and_return({'width' => 30, 'height' => 20})
+    expect(watir_element.width).to eql 30
+  end
+
+  it "should have a centre" do
+    allow(watir_driver).to receive(:wd).and_return(watir_driver)
+    expect(watir_driver).to receive(:location).and_return({'y' => 80, 'x' => 40})
+    expect(watir_driver).to receive(:size).and_return({'width' => 30, 'height' => 20})
+    expect(watir_element.centre).to include(
+      'y' => 90,
+      'x' => 55
+    )
+  end
+
+  it "should have a centre greater than y position" do
+    allow(watir_driver).to receive(:wd).and_return(watir_driver)
+    expect(watir_driver).to receive(:location).and_return({'y' => 80, 'x' => 40}).twice
+    expect(watir_driver).to receive(:size).and_return({'width' => 30, 'height' => 20})
+    expect(watir_element.centre['y']).to be > watir_element.location['y']
+  end
+
+  it "should have a centre greater than x position" do
+    allow(watir_driver).to receive(:wd).and_return(watir_driver)
+    expect(watir_driver).to receive(:location).and_return({'y' => 80, 'x' => 40}).twice
+    expect(watir_driver).to receive(:size).and_return({'width' => 30, 'height' => 20})
+    expect(watir_element.centre['x']).to be > watir_element.location['x']
+  end
 end

data/spec/page-object/selenium_accessors_spec.rb

@@ -35,7 +35,8 @@ class SeleniumAccessorsTestPageObject
   canvas(:my_canvas, :id => 'canvas')
   audio(:acdc, :id => 'audio_id')
   video(:movie, :id => 'movie_id')
-  b(:bold, :id=>'bold')
+  b(:bold, :id => 'bold')
+  i(:italic, :id => 'italic')
 end
 
 class SeleniumBlockPageObject
@@ -134,13 +135,17 @@ class SeleniumBlockPageObject
   b :bold do |element|
     'b'
   end
+
+  i :italic do |element|
+    'i'
+  end
 end
 
 describe PageObject::Accessors do
   let(:selenium_browser) { mock_selenium_browser }
   let(:selenium_page_object) { SeleniumAccessorsTestPageObject.new(selenium_browser) }
   let(:block_page_object) { SeleniumBlockPageObject.new(selenium_browser) }
-  
+
   before(:each) do
     allow(selenium_browser).to receive(:switch_to).and_return(selenium_browser)
     allow(selenium_browser).to receive(:default_content)
@@ -241,7 +246,7 @@ describe PageObject::Accessors do
       element = selenium_page_object.state_element
       expect(element).to be_instance_of PageObject::Elements::SelectList
     end
-    
+
     it "should return list of selection options" do
       option1 = double('option')
       option2 = double('option')
@@ -251,10 +256,10 @@ describe PageObject::Accessors do
       select_element = double("select")
       expect(select_element).to receive(:options).twice.and_return([option1, option2])
       expect(selenium_page_object).to receive(:state_element).and_return(select_element)
-      
+
       expect(selenium_page_object.state_options).to eql ["CA","OH"]
     end
-    
+
   end
 
 
@@ -417,21 +422,21 @@ describe PageObject::Accessors do
       expect(element).to be_instance_of PageObject::Elements::OrderedList
     end
   end
-  
+
   describe "h1 accessors" do
     it "should retrieve the text from the h1" do
       expect(selenium_browser).to receive(:find_element).and_return(selenium_browser)
       expect(selenium_browser).to receive(:text).and_return("value")
       expect(selenium_page_object.heading1).to eql "value"
     end
-  
+
     it "should retrieve the element from the page" do
       expect(selenium_browser).to receive(:find_element).and_return(selenium_browser)
       element = selenium_page_object.heading1_element
       expect(element).to be_instance_of PageObject::Elements::Heading
     end
   end
-  
+
   describe "h2 accessors" do
     it "should retrieve the text from the h2" do
       expect(selenium_browser).to receive(:find_element).and_return(selenium_browser)
@@ -567,7 +572,7 @@ describe PageObject::Accessors do
       end
     end
   end
-  
+
   describe "audio accessors" do
     context "when called on a page object" do
       it "should generate accessor methods" do
@@ -606,4 +611,18 @@ describe PageObject::Accessors do
     end
   end
 
+  describe "i accessors" do
+    it "should retrieve the text from the i" do
+      expect(selenium_browser).to receive(:find_element).and_return(selenium_browser)
+      expect(selenium_browser).to receive(:text).and_return("value")
+      expect(selenium_page_object.italic).to eql "value"
+    end
+
+    it "should retrieve the element from the page" do
+      expect(selenium_browser).to receive(:find_element).and_return(selenium_browser)
+      element = selenium_page_object.italic_element
+      expect(element).to be_instance_of PageObject::Elements::Italic
+    end
+  end
+
 end