page-object 1.2.0 → 1.2.1

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

@@ -1,26 +0,0 @@
-require 'spec_helper'
-require 'page-object/elements'
-
-describe PageObject::Elements::Span do
-  let(:span) { PageObject::Elements::Span }
-
-  describe "when mapping how to find an element" do
-    it "should map watir types to same" do
-      [:class, :id, :index, :text, :title, :xpath].each do |t|
-        identifier = span.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, :text, :title, :xpath].each do |t|
-        key, value = span.selenium_identifier_for t => 'value'
-        expect(key).to eql t
-      end
-    end
-  end
-
-  it "should register with tag_name :span" do
-    expect(::PageObject::Elements.element_class_for(:span)).to eql ::PageObject::Elements::Span
-  end
-end

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

@@ -1,21 +0,0 @@
-require 'spec_helper'
-require 'page-object/elements'
-
-describe PageObject::Elements::TableCell do
-
-  context "interface" do
-    it "should register with tag_name :td" do
-      expect(::PageObject::Elements.element_class_for(:td)).to eql ::PageObject::Elements::TableCell
-    end
-
-    it "should register with tag_name :th" do
-      expect(::PageObject::Elements.element_class_for(:th)).to eql ::PageObject::Elements::TableCell
-    end
-
-    it "should always be enabled" do
-      table_cell_element = double('table_cell_element')
-      table_cell = PageObject::Elements::TableCell.new(table_cell_element, :platform => :selenium_webdriver)
-      expect(table_cell.enabled?).to be true
-    end
-  end
-end

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

@@ -1,70 +0,0 @@
-require 'spec_helper'
-require 'page-object/elements'
-
-describe PageObject::Elements::TableRow do
-  let(:table_cell) { double('table_cell') }
-  let(:table_row_driver) { double('table_row_driver') }
-
-  describe "interface" do
-
-    it "should register with tag_name :tr" do
-      expect(::PageObject::Elements.element_class_for(:tr)).to eql ::PageObject::Elements::TableRow
-    end
-    
-    context "for selenium" do
-      it "should return a table cell when indexed" do
-        table_row = PageObject::Elements::TableRow.new(table_row_driver, :platform => :selenium_webdriver)
-        allow(table_row).to receive(:columns).and_return(2)
-        expect(table_row_driver).to receive(:find_elements).with(:xpath, ".//child::td|th").and_return(table_cell)
-        expect(table_cell).to receive(:[]).and_return(table_cell)
-        expect(table_row[0]).to be_instance_of PageObject::Elements::TableCell
-      end
-
-      it "should retrun the number of columns" do
-        table_row = PageObject::Elements::TableRow.new(table_row_driver, :platform => :selenium_webdriver)
-        expect(table_row_driver).to receive(:find_elements).with(:xpath, ".//child::td|th").and_return(table_row_driver)
-        expect(table_row_driver).to receive(:size).and_return(3)
-        expect(table_row.columns).to eql 3
-      end
-
-      it "should iterate over the table columns" do
-        table_row = PageObject::Elements::TableRow.new(table_row_driver, :platform => :selenium_webdriver)
-        expect(table_row).to receive(:columns).and_return(2)
-        allow(table_row).to receive(:[]).and_return(table_row_driver)
-        count = 0
-        table_row.each { |e| count += 1 }
-        expect(count).to eql 2
-      end
-    end
-
-    context "for watir" do
-      before(:each) do
-        allow(table_row_driver).to receive(:find_elements).and_return(table_row_driver)
-      end
-
-      it "should return a table cell when indexed" do
-        table_row = PageObject::Elements::TableRow.new(table_row_driver, :platform => :watir_webdriver)
-        allow(table_row).to receive(:columns).and_return(2)
-        expect(table_row_driver).to receive(:[]).with(1).and_return(table_cell)
-        expect(table_row[1]).to be_instance_of PageObject::Elements::TableCell
-      end
-
-      it "should return the number of columns" do
-        table_row = PageObject::Elements::TableRow.new(table_row_driver, :platform => :watir_webdriver)
-        allow(table_row_driver).to receive(:wd).and_return(table_row_driver)
-        expect(table_row_driver).to receive(:find_elements).with(:xpath, ".//child::td|th").and_return(table_row_driver)
-        expect(table_row_driver).to receive(:size).and_return(3)
-        expect(table_row.columns).to eql 3
-      end
-
-      it "should iterate over the table columns" do
-        table_row = PageObject::Elements::TableRow.new(table_row_driver, :platform => :watir_webdriver)
-        expect(table_row).to receive(:columns).and_return(2)
-        allow(table_row).to receive(:[])
-        count = 0
-        table_row.each { |e| count += 1 }
-        expect(count).to eql 2
-      end
-    end
-  end
-end

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

@@ -1,98 +0,0 @@
-require 'spec_helper'
-require 'page-object/elements'
-
-describe PageObject::Elements::Table do
-  describe "when mapping how to find an element" do
-    it "should map watir types to same" do
-      [:class, :id, :index, :xpath].each do |t|
-        identifier = PageObject::Elements::Table.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 = PageObject::Elements::Table.selenium_identifier_for t => 'value'
-        expect(key).to eql t
-      end
-    end
-  end
-
-  describe "interface" do
-    let(:table_element) { double('table_element') }
-
-    before(:each) do
-      allow(table_element).to receive(:[]).and_return(table_element)
-      allow(table_element).to receive(:find_elements).and_return(table_element)
-    end
-
-    it "should register with tag_name :table" do
-      expect(::PageObject::Elements.element_class_for(:table)).to eql ::PageObject::Elements::Table
-    end
-
-    context "for watir" do
-      let(:watir_table) { PageObject::Elements::Table.new(table_element, :platform => :watir_webdriver) }
-      
-      it "should return a table row when indexed" do
-        allow(table_element).to receive(:[]).with(1).and_return(table_element)
-        expect(watir_table[1]).to be_instance_of PageObject::Elements::TableRow
-      end
-
-      it "should return the first row" do
-        allow(table_element).to receive(:[]).with(0).and_return(table_element)
-        expect(watir_table.first_row).to be_instance_of PageObject::Elements::TableRow
-      end
-
-      it "shoudl return the last row" do
-        allow(table_element).to receive(:[]).with(-1).and_return(table_element)
-        expect(watir_table.last_row).to be_instance_of PageObject::Elements::TableRow
-      end
-
-      it "should return the number of rows" do
-        allow(table_element).to receive(:wd).and_return(table_element)
-        expect(table_element).to receive(:find_elements).with(:xpath, ".//child::tr").and_return(table_element)
-        expect(table_element).to receive(:size).and_return(2)
-        expect(watir_table.rows).to eql 2
-      end
-
-      it "should iterate over the table rows" do
-        expect(watir_table).to receive(:rows).and_return(2)
-        count = 0
-        watir_table.each { |e| count += 1 }
-        expect(count).to eql 2
-      end
-    end
-
-    context "for selenium" do
-      let(:selenium_table) { PageObject::Elements::Table.new(table_element, :platform => :selenium_webdriver) }
-      
-      it "should return a table row when indexed" do
-        expect(table_element).to receive(:find_elements).with(:xpath, ".//child::tr").and_return(table_element)
-        expect(selenium_table[1]).to be_instance_of PageObject::Elements::TableRow
-      end
-
-      it "should return the first row" do
-        allow(table_element).to receive(:[]).with(0).and_return(table_element)
-        expect(selenium_table.first_row).to be_instance_of PageObject::Elements::TableRow
-      end
-
-      it "shoudl return the last row" do
-        allow(table_element).to receive(:[]).with(-1).and_return(table_element)
-        expect(selenium_table.last_row).to be_instance_of PageObject::Elements::TableRow
-      end
-
-      it "should return the number of rows" do
-        expect(table_element).to receive(:find_elements).with(:xpath, ".//child::tr").and_return(table_element)
-        expect(table_element).to receive(:size).and_return(2)
-        expect(selenium_table.rows).to eql 2
-      end
-
-      it "should iterate over the table rows" do
-        allow(selenium_table).to receive(:rows).and_return(2)
-        count = 0
-        selenium_table.each { |e| count += 1 }
-        expect(count).to eql 2
-      end
-    end
-  end
-end

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

@@ -1,39 +0,0 @@
-require 'spec_helper'
-require 'page-object/elements'
-
-describe PageObject::Elements::TextArea do
-  let(:textarea) { PageObject::Elements::TextArea }
-
-  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 = textarea.watir_identifier_for t => 'value'
-        expect(identifier.keys.first).to eql t
-      end
-    end
-
-    it "should map selenium types to same" do
-      [:class, :id, :name, :xpath, :index].each do |t|
-        key, value = textarea.selenium_identifier_for t => 'value'
-        expect(key).to eql t
-      end
-    end
-  end
-  
-  describe "interface" do
-
-    it "should register with tag_name :textarea" do
-      expect(::PageObject::Elements.element_class_for(:textarea)).to eql ::PageObject::Elements::TextArea
-    end
-    
-    context "for Selenium" do
-      it "should set its' value" do
-        text_area_element = double('text_area')
-        text_area = PageObject::Elements::TextArea.new(text_area_element, :platform => :selenium_webdriver)
-        expect(text_area_element).to receive(:clear)
-        expect(text_area_element).to receive(:send_keys).with('Joseph')
-        text_area.value = 'Joseph'
-      end
-    end
-  end
-end

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

@@ -1,77 +0,0 @@
-require 'spec_helper'
-require 'page-object/elements'
-
-describe PageObject::Elements::UnorderedList do
-  let(:ul) { PageObject::Elements::UnorderedList }
-
-  describe "when mapping how to find an element" do
-    it "should map watir types to same" do
-      [:class, :id, :index, :xpath].each do |t|
-        identifier = ul.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 = ul.selenium_identifier_for t => 'value'
-        expect(key).to eql t
-      end
-    end
-  end
-
-  describe "interface" do
-    let(:ul_element) { double('ul_element') }
-
-    it "should register with tag_name :ul" do
-      expect(::PageObject::Elements.element_class_for(:ul)).to eql ::PageObject::Elements::UnorderedList
-    end
-
-    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)
-        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])
-        expect(ul.items).to eql 1
-      end
-
-      it "should know how to iterate over the items" do
-        ul = PageObject::Elements::UnorderedList.new(ul_element, :platform => :watir_webdriver)
-        expect(ul).to receive(:items).and_return(5)
-        allow(ul).to receive(:[])
-        count = 0
-        ul.each { |item| count += 1 }
-        expect(count).to eql 5
-      end
-    end
-
-    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, 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.items).to eql 1
-      end
-
-      it "should know how to iterate over the items" do
-        ul = PageObject::Elements::UnorderedList.new(ul_element, :platform => :selenium_webdriver)
-        expect(ul).to receive(:items).and_return(5)
-        allow(ul).to receive(:[])
-        count = 0
-        ul.each { |item| count += 1 }
-        expect(count).to eql 5
-      end
-    end
-  end
-end

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

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

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

@@ -1,193 +0,0 @@
-require 'spec_helper'
-require 'page-object/elements/element'
-
-describe "Element for Watir" do
-  let(:watir_driver) { double('watir_driver') }
-  let(:watir_element) { ::PageObject::Elements::Element.new(watir_driver, :platform => :watir_webdriver) }
-
-  before(:each) do
-    allow(Selenium::WebDriver::Mouse).to receive(:new).and_return(watir_driver)
-  end
-
-  it "should know when it is visible" do
-    allow(watir_driver).to receive(:present?).and_return(true)
-    allow(watir_driver).to receive(:displayed?).and_return(true)
-    expect(watir_element.visible?).to eql true
-  end
-
-  it "should know when it is not visible" do
-    allow(watir_driver).to receive(:present?).and_return(false)
-    allow(watir_driver).to receive(:displayed?).and_return(false)
-    expect(watir_element.visible?).to eql false
-  end
-
-  it "should know when it exists" do
-    allow(watir_driver).to receive(:exists?).and_return(true)
-    expect(watir_element.exists?).to eql true
-  end
-
-  it "should know when it does not exist" do
-    allow(watir_driver).to receive(:exists?).and_return(false)
-    allow(watir_driver).to receive(:nil?).and_return(true)
-    expect(watir_element.exists?).to eql false
-  end
-
-  it "should be able to return the text contained in the element" do
-    expect(watir_driver).to receive(:text).and_return("my text")
-    expect(watir_element.text).to eql "my text"
-  end
-
-  it "should know when it is equal to another" do
-    expect(watir_driver).to receive(:==).and_return(true)
-    expect(watir_element).to eq watir_element
-  end
-
-  it "should know when it is not equal to another" do
-    expect(watir_element).not_to eq 'not an element'
-  end
-
-  it "should return its tag name" do
-    expect(watir_driver).to receive(:tag_name).and_return("h1")
-    expect(watir_element.tag_name).to eql "h1"
-  end
-
-  it "should know its value" do
-    allow(watir_driver).to receive(:value).and_return("value")
-    allow(watir_driver).to receive(:attribute).and_return("value")
-    expect(watir_element.value).to eql "value"
-  end
-
-  it "should know how to retrieve the value of an attribute" do
-    allow(watir_driver).to receive(:attribute_value).and_return(true)
-    allow(watir_driver).to receive(:attribute).and_return(true)
-    expect(watir_element.attribute("readonly")).to be true
-  end
-
-  it "should be clickable" do
-    expect(watir_driver).to receive(:click)
-    watir_element.click
-  end
-  
-  it "should be double clickable" do
-    expect(watir_driver).to receive(:double_click)
-    watir_element.double_click
-  end
-  
-  it "should be right clickable" do
-    allow(watir_driver).to receive(:right_click)
-    allow(watir_driver).to receive(:context_click)
-    watir_element.right_click
-  end
-
-  it "should be able to block until it is present" do
-    allow(watir_driver).to receive(:wait_until_present).with(10)
-    watir_element.when_present(10)
-  end
-  
-  it "should return the element when it is present" do
-    allow(watir_driver).to receive(:wait_until_present).with(10)
-    element = watir_element.when_present(10)
-    expect(element).to equal watir_element
-  end
-
-  it "should use the overriden wait when set" do
-    PageObject.default_element_wait = 20
-    allow(watir_driver).to receive(:wait_until_present).with(20)
-    watir_element.when_present
-  end
-
-  it "should be able to block until it is visible" do
-    allow(::Watir::Wait).to receive(:until).with(10, "Element was not visible in 10 seconds")
-    allow(watir_driver).to receive(:displayed?).and_return(true)
-    watir_element.when_visible(10)
-  end
-  
-  it "should return the element when it is visible" do
-    allow(::Watir::Wait).to receive(:until).with(10, "Element was not visible in 10 seconds")
-    allow(watir_driver).to receive(:displayed?).and_return(true)
-    element = watir_element.when_visible(10)
-    expect(element).to equal watir_element
-  end
-
-  it "should be able to block until it is not visible" do
-    allow(::Watir::Wait).to receive(:while).with(10, "Element still visible after 10 seconds")
-    allow(watir_driver).to receive(:displayed?).and_return(false)
-    watir_element.when_not_visible(10)
-  end
-  
-  it "should return the element when it is not visible" do
-    allow(::Watir::Wait).to receive(:while).with(10, "Element still visible after 10 seconds")
-    allow(watir_driver).to receive(:displayed?).and_return(false)
-    element = watir_element.when_not_visible(10)
-    expect(element).to equal watir_element
-  end
-
-  it "should be able to block until a user define event fires true" do
-    allow(::Watir::Wait).to receive(:until).with(10, "Element blah")
-    watir_element.wait_until(10, "Element blah") {true}
-  end
-  
-  it "should send keys to the element" do
-    expect(watir_driver).to receive(:send_keys).with([:control, 'a'])
-    watir_element.send_keys([:control, 'a'])
-  end
-  
-  it "should clear its' contents" do
-    expect(watir_driver).to receive(:clear)
-    watir_element.clear
-  end
-
-  it "should scroll into view" do
-    allow(watir_driver).to receive(:wd).and_return(watir_driver)
-    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