page_object 1.1.1

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'
+        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'
+        expect(key).to eql 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
+        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
+        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
+        expect(area_element).to receive(:attribute).with(:href).and_return('twitter.com')
+        expect(selenium_area.href).to eql 'twitter.com'
+      end
+    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

@@ -0,0 +1,64 @@
+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'
+        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'
+        expect(key).to eql t
+      end
+    end
+  end
+
+  describe "interface" do
+    let(:button_element) { double('button_element') }
+
+    it "should register with type :submit" do
+      expect(::PageObject::Elements.element_class_for(:input, :submit)).to eql ::PageObject::Elements::Button
+    end
+
+    it "should register with type :image" do
+      expect(::PageObject::Elements.element_class_for(:input, :image)).to eql ::PageObject::Elements::Button
+    end
+
+    it "should register with type :button" do
+      expect(::PageObject::Elements.element_class_for(:input, :button)).to eql ::PageObject::Elements::Button
+    end
+
+    it "should retisger with type :reset" do
+      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)
+        expect(lambda { button.text }).to raise_error
+      end
+
+      it "should return text for a button tag button" do
+        allow(button_element).to receive(:tag_name).and_return('button')
+        allow(button_element).to receive(:text).and_return('button?')
+        button = PageObject::Elements::Button.new(button_element, :platform => :selenium_webdriver)
+        expect(button.text).to eq 'button?'
+      end
+
+      it "should return text for an input tag button" do
+        allow(button_element).to receive(:tag_name).and_return('input')
+        allow(button_element).to receive(:attribute).with('value').and_return('button!')
+        button = PageObject::Elements::Button.new(button_element, :platform => :selenium_webdriver)
+        expect(button.text).to eq 'button!'
+      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'
+        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'
+        expect(key).to eql 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
+        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
+        expect(canvas_element).to receive(:attribute).with(:height).and_return("100")
+        expect(selenium_canvas.height).to eql 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'
+        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'
+        expect(key).to eql 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
+      expect(::PageObject::Elements.element_class_for(:input, :checkbox)).to eql ::PageObject::Elements::CheckBox
+    end
+    
+    context "for selenium" do
+      it "should check" do
+        expect(check_box).to receive(:click)
+        expect(check_box).to receive(:selected?).and_return(false)
+        selenium_cb.check
+      end
+
+      it "should uncheck" do
+        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
+        expect(check_box).to receive(:selected?).and_return(true)
+        expect(selenium_cb).to 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'
+        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'
+        expect(key).to eql t
+      end
+    end
+
+    describe "interface" do
+      it "should register with tag :div" do
+        expect(::PageObject::Elements.element_class_for(:div)).to eql ::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
+        expect(result[:xpath]).to eql ".//#{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
+        expect(how).to eql :xpath
+        expect(what).to eql "(.//#{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
+        expect(how).to eql :xpath
+        expect(what).to 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
+        expect(how).to eql :xpath
+        expect(what).to eql "(.//#{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
+        expect(how).to eql :xpath
+        expect(what).to 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
+        expect(how).to eql :xpath
+        expect(what).to eql ".//#{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
+        expect(what).to 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
+      expect(native).to receive(:enabled?).and_return(true)
+      expect(element).to be_enabled
+    end
+
+    it "should click the native" do
+      expect(native).to receive(:click)
+      element.click
+    end
+
+    it "should double click the native" do
+      expect(native).to receive(:double_click)
+      element.double_click
+    end
+
+    it "should inspect the native" do
+      expect(native).to receive(:inspect)
+      element.inspect
+    end
+
+    it "should retrieve the native's style" do
+      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
+      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

@@ -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'
+        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

@@ -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
+      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