page-object 1.2.0 → 1.2.1

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

@@ -1,45 +0,0 @@
-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

@@ -1,29 +0,0 @@
-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

@@ -1,64 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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') }
-    let(:wd) { double('wd') }
-
-    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(:size).and_return({'width' => 400})
-        expect(selenium_canvas.width).to eql 400
-      end
-
-      it "should know its height" do
-        expect(canvas_element).to receive(:size).and_return({'height' => 100})
-        expect(selenium_canvas.height).to eql 100
-      end
-    end
-  end
-end

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

@@ -1,49 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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

@@ -1,196 +0,0 @@
-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(: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
-      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
-
-    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