meeane-page-object 0.1.10 → 0.1.11

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

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

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

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

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

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

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