meeane-page-object 0.1.8

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

@@ -0,0 +1,45 @@
+require 'spec_helper'
+require 'page-object/elements'
+
+describe PageObject::Elements::Area do
+  let(:area) { PageObject::Elements::Area }
+
+  context "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 = area.watir_identifier_for t => 'value'
+        identifier.keys.first.should == 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
+      end
+    end
+  end
+
+  context "implementation" do
+    let(:area_element) { double('area_element') }
+
+    context "when using selenium" 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"
+      end
+
+      it "should know its shape" do
+        area_element.should_receive(:attribute).with(:shape).and_return('circle')
+        selenium_area.shape.should == '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'
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+require 'spec_helper'
+require 'page-object/elements'
+
+describe PageObject::Elements::Button do
+  let(:button) { PageObject::Elements::Button }
+
+  context "when mapping how to find an element" 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
+      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
+      end
+    end
+  end
+
+  describe "interface" 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
+    end
+
+    it "should register with type :image" do
+      ::PageObject::Elements.element_class_for(:input, :image).should == ::PageObject::Elements::Button
+    end
+
+    it "should register with type :button" do
+      ::PageObject::Elements.element_class_for(:input, :button).should == ::PageObject::Elements::Button
+    end
+
+    it "should retisger with type :reset" do
+      ::PageObject::Elements.element_class_for(:input, :reset).should == ::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
+      end
+    end
+  end
+
+end

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

@@ -0,0 +1,40 @@
+require 'spec_helper'
+require 'page-object/elements'
+
+describe PageObject::Elements::Canvas do
+  let(:area) { PageObject::Elements::Canvas }
+
+  context "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 = area.watir_identifier_for t => 'value'
+        identifier.keys.first.should == 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
+      end
+    end
+  end
+
+  context "implementation" do
+    let(:canvas_element) { double('canvas_element') }
+
+    context "when using selenium" 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
+      end
+
+      it "should know its height" do
+        canvas_element.should_receive(:attribute).with(:height).and_return("100")
+        selenium_canvas.height.should == 100
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+require 'spec_helper'
+require 'page-object/elements'
+
+describe PageObject::Elements::CheckBox do
+  let(:checkbox) { PageObject::Elements::CheckBox }
+
+  describe "when mapping how to find an element" 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
+      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
+      end
+    end
+  end
+  
+  describe "interface" do
+    let(:check_box) { double('check_box') }
+    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
+    end
+    
+    context "for selenium" do
+      it "should check" do
+        check_box.should_receive(:click)
+        check_box.should_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)
+        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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+require 'spec_helper'
+require 'page-object/elements'
+
+describe PageObject::Elements::Div do
+  let(:div) { PageObject::Elements::Div }
+
+  describe "when mapping how to find an element" 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
+      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
+      end
+    end
+
+    describe "interface" do
+      it "should register with tag :div" do
+        ::PageObject::Elements.element_class_for(:div).should == ::PageObject::Elements::Div
+      end
+    end
+  end
+end

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

@@ -0,0 +1,114 @@
+require 'spec_helper'
+require 'page-object/elements'
+
+
+describe "Element" do
+
+  context "when building the identifiers for Watir" do
+    it "should build xpath when finding elements by name where not supported" 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']"
+      end
+    end
+  end
+
+  context "when building the identifiers for Selenium" do
+    def all_basic_elements
+      ['textarea', 'select', 'a', 'div', 'span', 'table', 'td', 'img', 'form', 'li', 'ul', 'ol']
+    end
+
+    def all_input_elements
+      ['text', 'hidden', 'checkbox', 'radio']
+    end
+
+    it "should build xpath when index is provided for basic elements" 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]"
+      end
+    end
+
+    it "should should build xpath when index is provided for input elements" 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]"
+      end
+    end
+
+    it "should build xpath when locating basic elements by name and index" 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]"
+      end
+    end
+
+    it "should build xpath when locating input elements by name and index" 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]"
+      end
+    end
+
+    it "should build xpath when locating basic elements by name and class" 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']"
+      end
+    end
+
+    it "should build xpath when locating input elements by name and class" 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']"
+      end
+    end
+  end
+
+  context "interaction with native element" do
+    let(:native) { double('') }
+    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
+    end
+
+    it "should click the native" do
+      native.should_receive(:click)
+      element.click
+    end
+
+    it "should double click the native" do
+      native.should_receive(:double_click)
+      element.double_click
+    end
+
+    it "should inspect the native" do
+      native.should_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'
+    end
+
+    it "should know if a native is disabled" do
+      native.should_receive(:enabled?).and_return(false)
+      element.should be_disabled
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+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'
+        identifier.keys.first.should == 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
+      end
+    end
+  end
+
+  describe "interface" do
+    let(:filefield) { double('file_field') }
+
+    it "should register as type :file" do
+      ::PageObject::Elements.element_class_for(:input, :file).should == ::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')
+        selenium_file_field.value = 'a file'
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+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
+      ::PageObject::Elements.element_class_for(:form).should == ::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)
+        form.submit
+      end
+    end
+
+    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)
+        form.submit
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+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'
+        identifier.keys.first.should == 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
+      end
+    end
+  end
+
+  describe "interface" do
+    it "should register with tag :h1" do
+      ::PageObject::Elements.element_class_for(:h1).should == ::PageObject::Elements::Heading
+    end
+
+    it "should register with tag :h2" do
+      ::PageObject::Elements.element_class_for(:h2).should == ::PageObject::Elements::Heading
+    end
+
+    it "should register with tag :h3" do
+      ::PageObject::Elements.element_class_for(:h3).should == ::PageObject::Elements::Heading
+    end
+
+    it "should register with tag :h4" do
+      ::PageObject::Elements.element_class_for(:h4).should == ::PageObject::Elements::Heading
+    end
+
+    it "should register with tag :h5" do
+      ::PageObject::Elements.element_class_for(:h5).should == ::PageObject::Elements::Heading
+    end
+
+    it "should register with tag :h6" do
+      ::PageObject::Elements.element_class_for(:h6).should == ::PageObject::Elements::Heading
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+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'
+        identifier.keys.first.should == 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
+      end
+    end
+  end
+
+  describe "interface" do
+    it "should register with type :hidden" do
+      ::PageObject::Elements.element_class_for(:input, :hidden).should == ::PageObject::Elements::HiddenField
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+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'
+        identifier.keys.first.should == 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
+      end
+    end
+  end
+
+  describe "interface" do
+    let(:image_element) { double('image_element') }
+
+    before(:each) do
+      image_element.stub(:size).and_return(image_element)
+    end
+
+    it "should register with tag_name :img" do
+      ::PageObject::Elements.element_class_for(:img).should == ::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
+      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
+      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)
+        image_element.should_receive(:size).and_return(dim)
+        dim.should_receive(:width).and_return(100)
+        image.width.should == 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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+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'
+        identifier.keys.first.should == 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
+      end
+    end
+
+    describe "interface" do
+      it "should register with tag :label" do
+        ::PageObject::Elements.element_class_for(:label).should == ::PageObject::Elements::Label
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,49 @@
+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'
+        identifier.keys.first.should == 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
+      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
+      end
+    end
+
+    it "should map watir types to selenium" do
+      key, value = link.selenium_identifier_for :text => 'value'
+      key.should == :link_text
+    end
+  end
+
+  describe "interface" do
+    let(:link_element) { double('link_element') }
+
+    it "should register with tag :a" do
+      ::PageObject::Elements.element_class_for(:a).should == ::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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+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'
+        identifier.keys.first.should == 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
+      end
+    end
+
+    describe "interface" do
+      it "should register as tag_name :li" do
+        ::PageObject::Elements.element_class_for(:li).should == ::PageObject::Elements::ListItem
+      end
+    end
+  end
+end