page-object 1.2.0 → 1.2.1

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

@@ -1,39 +0,0 @@
-require 'spec_helper'
-require 'page-object/elements'
-
-describe PageObject::Elements::FileField do
-
-  describe "when mapping how to find an element" do
-    let(:filefield) { PageObject::Elements::FileField }
-
-    it "should map watir types to same" do
-      [:class, :id, :index, :name, :xpath, :title].each do |t|
-        identifier = filefield.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, :title].each do |t|
-        key, value = filefield.selenium_identifier_for t => 'value'
-        expect(key).to eql t
-      end
-    end
-  end
-
-  describe "interface" do
-    let(:filefield) { double('file_field') }
-
-    it "should register as type :file" do
-      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)
-        expect(filefield).to receive(:send_keys).with('a file')
-        selenium_file_field.value = 'a file'
-      end
-    end
-  end
-end

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

@@ -1,28 +0,0 @@
-require 'spec_helper'
-require 'page-object/elements'
-
-describe PageObject::Elements::Form do
-  describe "interface" do
-    let(:form_element) { double('form_element') }
-
-    it "should register with tag_name :form" do
-      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)
-        expect(form_element).to receive(:submit)
-        form.submit
-      end
-    end
-
-    context "for selenium" do
-      it "should submit a form" do
-        form = PageObject::Elements::Form.new(form_element, :platform => :selenium_webdriver)
-        expect(form_element).to receive(:submit)
-        form.submit
-      end
-    end
-  end
-end

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

@@ -1,48 +0,0 @@
-require 'spec_helper'
-require 'page-object/elements'
-
-describe PageObject::Elements::Heading do
-  let(:heading) { PageObject::Elements::Heading }
-
-  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 = heading.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 = heading.selenium_identifier_for t => 'value'
-        expect(key).to eql t
-      end
-    end
-  end
-
-  describe "interface" do
-    it "should register with tag :h1" do
-      expect(::PageObject::Elements.element_class_for(:h1)).to eql ::PageObject::Elements::Heading
-    end
-
-    it "should register with tag :h2" do
-      expect(::PageObject::Elements.element_class_for(:h2)).to eql ::PageObject::Elements::Heading
-    end
-
-    it "should register with tag :h3" do
-      expect(::PageObject::Elements.element_class_for(:h3)).to eql ::PageObject::Elements::Heading
-    end
-
-    it "should register with tag :h4" do
-      expect(::PageObject::Elements.element_class_for(:h4)).to eql ::PageObject::Elements::Heading
-    end
-
-    it "should register with tag :h5" do
-      expect(::PageObject::Elements.element_class_for(:h5)).to eql ::PageObject::Elements::Heading
-    end
-
-    it "should register with tag :h6" do
-      expect(::PageObject::Elements.element_class_for(:h6)).to eql ::PageObject::Elements::Heading
-    end
-  end
-end

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

@@ -1,28 +0,0 @@
-require 'spec_helper'
-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, :text, :xpath, :value].each do |t|
-        identifier = hiddenfield.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, :value].each do |t|
-        key, value = hiddenfield.selenium_identifier_for t => 'value'
-        expect(key).to eql t
-      end
-    end
-  end
-
-  describe "interface" do
-    it "should register with type :hidden" do
-      expect(::PageObject::Elements.element_class_for(:input, :hidden)).to eql ::PageObject::Elements::HiddenField
-    end
-  end
-end

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

@@ -1,66 +0,0 @@
-require 'spec_helper'
-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, :alt, :src].each do |t|
-        identifier = image.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, :alt, :src].each do |t|
-        key, value = image.selenium_identifier_for t => 'value'
-        expect(key).to eql t
-      end
-    end
-  end
-
-  describe "interface" do
-    let(:image_element) { double('image_element') }
-
-    before(:each) do
-      allow(image_element).to receive(:size).and_return(image_element)
-    end
-
-    it "should register with tag_name :img" do
-      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)
-        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)
-        expect(image_element).to receive(:height).and_return(120)
-        expect(image.height).to eql 120
-      end
-    end
-
-    context "for selenium" do
-      it "should know the images width" do
-        dim = double('dimension')
-        image = PageObject::Elements::Image.new(image_element, :platform => :selenium_webdriver)
-        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)
-        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
-end

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

@@ -1,29 +0,0 @@
-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/label_spec.rb

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

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

@@ -1,49 +0,0 @@
-require 'spec_helper'
-require 'page-object/elements'
-
-describe PageObject::Elements::Link do
-  let(:link) { PageObject::Elements::Link }
-
-  describe "when mapping how to find an element" 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'
-        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'
-        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'
-        expect(key).to eql t
-      end
-    end
-
-    it "should map watir types to selenium" do
-      key, value = link.selenium_identifier_for :text => 'value'
-      expect(key).to eql :link_text
-    end
-  end
-
-  describe "interface" do
-    let(:link_element) { double('link_element') }
-
-    it "should register with tag :a" do
-      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)
-        expect(lambda { link.value }).to raise_error
-      end
-    end
-  end
-end

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

@@ -1,29 +0,0 @@
-require 'spec_helper'
-require 'page-object/elements'
-
-describe PageObject::Elements::ListItem do
-  let(:list_item) { PageObject::Elements::ListItem }
-
-  describe "when mapping how to find an element" 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'
-        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'
-        expect(key).to eql t
-      end
-    end
-
-    describe "interface" do
-      it "should register as tag_name :li" do
-        expect(::PageObject::Elements.element_class_for(:li)).to eql ::PageObject::Elements::ListItem
-      end
-    end
-  end
-end
-

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

@@ -1,63 +0,0 @@
-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/nested_element_spec.rb

@@ -1,254 +0,0 @@
-require 'spec_helper'
-require 'page-object/elements'
-
-
-describe "Element with nested elements" do
-  context "in Watir" do
-    before(:each) do
-      @watir_driver = Watir::Element.new(nil, {})
-      @watir_element = PageObject::Elements::Element.new(@watir_driver, :platform => :watir_webdriver)
-    end
-    
-    it "should find nested links" do
-      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
-      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
-      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
-      expect(@watir_driver).to receive(:hidden).and_return(@watir_driver)
-      @watir_element.hidden_field_element
-    end
-
-    it "should find nested text areas" do
-      expect(@watir_driver).to receive(:textarea).and_return(@watir_driver)
-      @watir_element.text_area_element
-    end
-
-    it "should find a nested select list" do
-      expect(@watir_driver).to receive(:select_list).and_return(@watir_driver)
-      @watir_element.select_list_element
-    end
-
-    it "should find a nested checkbox" do
-      expect(@watir_driver).to receive(:checkbox).and_return(@watir_driver)
-      @watir_element.checkbox_element
-    end
-    
-    it "should find a nested radio button" do
-      expect(@watir_driver).to receive(:radio).and_return(@watir_driver)
-      @watir_element.radio_button_element
-    end
-    
-    it "should find a nested div" do
-      expect(@watir_driver).to receive(:div).and_return(@watir_driver)
-      @watir_element.div_element
-    end
-    
-    it "should find a nested span" do
-      expect(@watir_driver).to receive(:span).and_return(@watir_driver)
-      @watir_element.span_element
-    end
-    
-    it "should find a nested table" do
-      expect(@watir_driver).to receive(:table).and_return(@watir_driver)
-      @watir_element.table_element
-    end
-
-    it "should find a nested cell" do
-      expect(@watir_driver).to receive(:td).and_return(@watir_driver)
-      @watir_element.cell_element
-    end
-    
-    it "should find a nested image" do
-      expect(@watir_driver).to receive(:image).and_return(@watir_driver)
-      @watir_element.image_element
-    end
-    
-    it "should find a nested form" do
-      expect(@watir_driver).to receive(:form).and_return(@watir_driver)
-      @watir_element.form_element
-    end
-    
-    it "should find a nested ordered list" do
-      expect(@watir_driver).to receive(:ol).and_return(@watir_driver)
-      @watir_element.ordered_list_element
-    end
-    
-    it "should find a nested unordered list" do
-      expect(@watir_driver).to receive(:ul).and_return(@watir_driver)
-      @watir_element.unordered_list_element
-    end
-    
-    it "should find a nested list item" do
-      expect(@watir_driver).to receive(:li).and_return(@watir_driver)
-      @watir_element.list_item_element
-    end
-    
-    it "should find a nested h1" do
-      expect(@watir_driver).to receive(:h1).and_return(@watir_driver)
-      @watir_element.h1_element
-    end
-
-    it "should find a nested h2" do
-      expect(@watir_driver).to receive(:h2).and_return(@watir_driver)
-      @watir_element.h2_element
-    end
-
-    it "should find a nested h3" do
-      expect(@watir_driver).to receive(:h3).and_return(@watir_driver)
-      @watir_element.h3_element
-    end
-
-    it "should find a nested h4" do
-      expect(@watir_driver).to receive(:h4).and_return(@watir_driver)
-      @watir_element.h4_element
-    end
-
-    it "should find a nested h5" do
-      expect(@watir_driver).to receive(:h5).and_return(@watir_driver)
-      @watir_element.h5_element
-    end
-
-    it "should find a nested h6" do
-      expect(@watir_driver).to receive(:h6).and_return(@watir_driver)
-      @watir_element.h6_element
-    end
-  end
-  
-  context "in Selenium" do
-    before(:each) do
-      @selenium_driver = double('selenium')
-      @selenium_element = PageObject::Elements::Element.new(@selenium_driver, :platform => :selenium_webdriver)
-    end
-
-    it "should find nested links" do
-      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
-      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
-      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
-      expect(@selenium_driver).to receive(:find_element).and_return(@selenium_driver)
-      @selenium_element.hidden_field_element
-    end
-    
-    it "should find nested text areas" do
-      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
-      expect(@selenium_driver).to receive(:find_element).and_return(@selenium_driver)
-      @selenium_element.select_list_element
-    end
-    
-    it "should find a nested checkbox" do
-      expect(@selenium_driver).to receive(:find_element).and_return(@selenium_driver)
-      @selenium_element.checkbox_element
-    end
-    
-    it "should find a nested radio button" do
-      expect(@selenium_driver).to receive(:find_element).and_return(@selenium_driver)
-      @selenium_element.radio_button_element
-    end
-    
-    it "should find a nested div" do
-      expect(@selenium_driver).to receive(:find_element).and_return(@selenium_driver)
-      @selenium_element.div_element
-    end
-    
-    it "should find a nested span" do
-      expect(@selenium_driver).to receive(:find_element).and_return(@selenium_driver)
-      @selenium_element.span_element
-    end
-    
-    it "should find a nested table" do
-      expect(@selenium_driver).to receive(:find_element).and_return(@selenium_driver)
-      @selenium_element.table_element
-    end
-
-    it "should find a nested cell" do
-      expect(@selenium_driver).to receive(:find_element).and_return(@selenium_driver)
-      @selenium_element.cell_element
-    end
-    
-    it "should find a nested image" do
-      expect(@selenium_driver).to receive(:find_element).and_return(@selenium_driver)
-      @selenium_element.image_element
-    end
-    
-    it "should find a nested form" do
-      expect(@selenium_driver).to receive(:find_element).and_return(@selenium_driver)
-      @selenium_element.form_element
-    end
-    
-    it "should find an ordered list" do
-      expect(@selenium_driver).to receive(:find_element).and_return(@selenium_driver)
-      @selenium_element.ordered_list_element
-    end
-    
-    it "should find an unordered list" do
-      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
-      expect(@selenium_driver).to receive(:find_element).and_return(@selenium_driver)
-      @selenium_element.list_item_element
-    end
-    
-    it "should find a nested h1" do
-      expect(@selenium_driver).to receive(:find_element).and_return(@selenium_driver)
-      @selenium_element.h1_element
-    end
-    
-    it "should find a nested h2" do
-      expect(@selenium_driver).to receive(:find_element).and_return(@selenium_driver)
-      @selenium_element.h2_element
-    end
-
-    it "should find a nested h3" do
-      expect(@selenium_driver).to receive(:find_element).and_return(@selenium_driver)
-      @selenium_element.h3_element
-    end
-
-    it "should find a nested h4" do
-      expect(@selenium_driver).to receive(:find_element).and_return(@selenium_driver)
-      @selenium_element.h4_element
-    end
-
-    it "should find a nested h5" do
-      expect(@selenium_driver).to receive(:find_element).and_return(@selenium_driver)
-      @selenium_element.h5_element
-    end
-
-    it "should find a nested h6" do
-      expect(@selenium_driver).to receive(:find_element).and_return(@selenium_driver)
-      @selenium_element.h6_element
-    end
-
-    it "should find a nested paragraph" do
-      expect(@selenium_driver).to receive(:find_element).and_return(@selenium_driver)
-      @selenium_element.paragraph_element
-    end
-  end
-end