page-object 1.1.1 → 1.2.0

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

@@ -22,17 +22,18 @@ describe PageObject::Elements::Canvas do
 
   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(:attribute).with(:width).and_return("400")
+        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(:attribute).with(:height).and_return("100")
+        expect(canvas_element).to receive(:size).and_return({'height' => 100})
         expect(selenium_canvas.height).to eql 100
       end
     end

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

@@ -30,14 +30,14 @@ describe PageObject::Elements::OrderedList do
     context "for watir" do
       it "should return a list item when indexed" do
         ol = PageObject::Elements::OrderedList.new(ol_element, :platform => :watir_webdriver)
-        expect(ol_element).to receive(:find_elements).
+        expect(ol_element).to receive(:ols).
                                and_return([ol_element, ol_element])
         ol[1]
       end
 
       it "should know how many list items it contains" do
         ol = PageObject::Elements::OrderedList.new(ol_element, :platform => :watir_webdriver)
-        expect(ol_element).to receive(:find_elements).and_return([ol_element])
+        expect(ol_element).to receive(:ols).and_return([ol_element])
         expect(ol.items).to eql 1
       end
 

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

@@ -43,12 +43,12 @@ describe PageObject::Elements::SelectList do
       let(:watir_sel_list) { PageObject::Elements::SelectList.new(sel_list, :platform => :watir_webdriver) }
 
       it "should return an option when indexed" do
-        expect(sel_list).to receive(:find_elements).with(:xpath, ".//child::option").and_return(opts)
+        expect(sel_list).to receive(:options).with(no_args).and_return(opts)
         expect(watir_sel_list[0]).to be_instance_of PageObject::Elements::Option
       end
 
       it "should return an array of options" do
-        expect(sel_list).to receive(:find_elements).with(:xpath, ".//child::option").and_return(opts)
+        expect(sel_list).to receive(:options).with(no_args).and_return(opts)
         expect(watir_sel_list.options.size).to eql 2
       end
 

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

@@ -30,14 +30,14 @@ describe PageObject::Elements::UnorderedList do
     context "for watir" do
       it "should return a list item when indexed" do
         ul = PageObject::Elements::UnorderedList.new(ul_element, :platform => :watir_webdriver)
-        allow(ul_element).to receive(:find_elements).and_return(ul_element)
+        allow(ul_element).to receive(:uls).and_return(ul_element)
         expect(ul_element).to receive(:[])
         ul[1]
       end
 
       it "should know how many items it contains" do
         ul = PageObject::Elements::UnorderedList.new(ul_element, :platform => :watir_webdriver)
-        allow(ul_element).to receive(:find_elements).and_return([ul_element])
+        allow(ul_element).to receive(:uls).and_return([ul_element])
         expect(ul.items).to eql 1
       end
 

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

@@ -1,27 +1,33 @@
 require 'spec_helper'
 require 'page-object/elements'
 
-describe PageObject::Elements::ListItem do
+describe PageObject::Elements::Video do
 
-  let(:video) { PageObject::Elements::Video.new(double(''), :platform => :watir_webdriver) }
+  let(:video) { PageObject::Elements::Video.new(platform, :platform => :watir_webdriver) }
+  let(:platform) { double('platform')}
+  let(:wd) { double('wd') }
+
+  before do
+    allow(platform).to receive(:wd).and_return wd
+  end
 
   it "should return height when present" do
-    expect(video).to receive(:attribute).with(:height).and_return("20")
+    expect(wd).to receive(:size).and_return('height' => 20)
     expect(video.height).to eq(20)
   end
 
   it "should not return height when not present" do
-    expect(video).to receive(:attribute).with(:height).and_return(nil)
+    expect(wd).to receive(:size).and_return({})
     expect(video.height).to eq(nil)
   end
 
   it "should return width when present" do
-    expect(video).to receive(:attribute).with(:width).and_return("20")
+    expect(wd).to receive(:size).and_return('width' => 20)
     expect(video.width).to eq(20)
   end
 
   it "should not return width when not present" do
-    expect(video).to receive(:attribute).with(:width).and_return(nil)
+    expect(wd).to receive(:size).and_return({})
     expect(video.width).to eq(nil)
   end
 end

data/spec/page-object/page-object_spec.rb

@@ -86,17 +86,17 @@ describe PageObject do
       expect(selenium_page_object.platform).to be_kind_of PageObject::Platforms::SeleniumWebDriver::PageObject
     end
   end
-  
+
   context "when created with a non_bundled adapter" do
     let(:custom_adapter) { mock_adapter(:custom_browser, CustomPlatform) }
-    
+
     it "should be an instance of whatever that objects adapter is" do
       mock_adapters({:custom_adapter=>custom_adapter})
       custom_page_object = PageObjectTestPageObject.new(:custom_browser)
       expect(custom_page_object.platform).to be custom_adapter.create_page_object
     end
   end
-  
+
   context "when created with an object we do not understand" do
     it "should throw an error" do
       expect {
@@ -112,17 +112,17 @@ describe PageObject do
         expect(watir_page_object.platform).to receive(:attach_to_window)
         watir_page_object.attach_to_window("blah")
       end
-      
+
       it "should call initialize_page if it exists" do
         class CallbackPage
           include PageObject
           attr_reader :initialize_page_called
-        
+
           def initialize_page
             @initialize_page_called = true
           end
         end
-        
+
         @page = CallbackPage.new(watir_browser)
         expect(@page.initialize_page_called).to be true
       end
@@ -165,8 +165,36 @@ describe PageObject do
         expect(watir_browser).to receive(:type).and_return(:submit)
         expect(watir_page_object.element_with_focus.class).to eql PageObject::Elements::Button
       end
+
+      context "when sent a missing method" do
+        it "should not respond to it if the @root_element doesn't exist" do
+          # nil responds to `to_i`, @root_element is nil, but the page object doesn't respond
+          expect(nil).to respond_to :to_i
+          expect(watir_page_object.instance_variable_get(:@root_element)).to be nil
+          expect(watir_page_object).not_to respond_to :to_i
+          expect { watir_page_object.to_i }.to raise_error NoMethodError
+        end
+
+        it "should respond to it if the @root_element exists and responds" do
+          # sanity checks
+          expect(watir_page_object.instance_variable_get(:@root_element)).to be nil
+          expect(watir_page_object).not_to respond_to :bar
+          expect(watir_page_object).not_to respond_to :baz
+          # set @root_element
+          class Foo; def bar; :bar_called; end; private; def baz; end; end
+          watir_page_object.instance_variable_set(:@root_element, Foo.new)
+          # test
+          expect(watir_page_object).to respond_to :bar
+          expect(watir_page_object).not_to respond_to :baz
+          expect(watir_page_object.bar).to eq :bar_called
+          expect { watir_page_object.baz }.to raise_error NoMethodError
+          # can't get to private methods
+          expect(watir_page_object.respond_to?(:baz, true)).to be false
+          expect { watir_page_object.send(:baz) }.to raise_error NoMethodError
+        end
+      end
     end
-    
+
     context "when using WatirPageObject" do
       it "should display the page text" do
         expect(watir_browser).to receive(:element).and_return(watir_browser)
@@ -235,24 +263,24 @@ describe PageObject do
         expect(watir_browser).to receive(:execute_script).and_return("abc")
         expect(watir_page_object.execute_script("333")).to eql "abc"
       end
-      
+
       it "should convert a modal popup to a window" do
         expect(watir_browser).to receive(:execute_script)
         watir_page_object.modal_dialog {}
       end
-      
+
       it "should switch to a new window with a given title" do
         expect(watir_browser).to receive(:window).with(:title => /My\ Title/).and_return(watir_browser)
         expect(watir_browser).to receive(:use)
         watir_page_object.attach_to_window(:title => "My Title")
       end
-      
+
       it "should switch to a new window with a given url" do
         expect(watir_browser).to receive(:window).with(:url => /success\.html/).and_return(watir_browser)
         expect(watir_browser).to receive(:use)
         watir_page_object.attach_to_window(:url => "success.html")
       end
-      
+
       it "should refresh the page contents" do
         expect(watir_browser).to receive(:refresh)
         watir_page_object.refresh
@@ -267,18 +295,18 @@ describe PageObject do
         expect(watir_browser).to receive(:forward)
         watir_page_object.forward
       end
-      
+
       it "should know its' current url" do
         expect(watir_browser).to receive(:url).and_return("cheezyworld.com")
         expect(watir_page_object.current_url).to eql "cheezyworld.com"
       end
-      
+
       it "should know how to clear all of the cookies from the browser" do
         expect(watir_browser).to receive(:cookies).and_return(watir_browser)
         expect(watir_browser).to receive(:clear)
         watir_page_object.clear_cookies
       end
-      
+
       it "should be able to save a screenshot" do
         expect(watir_browser).to receive(:wd).and_return(watir_browser)
         expect(watir_browser).to receive(:save_screenshot)
@@ -342,12 +370,12 @@ describe PageObject do
         selenium_page_object.prompt("blah") do
         end
       end
-      
+
       it "should convert a modal popup to a window" do
         expect(selenium_browser).to receive(:execute_script)
         selenium_page_object.modal_dialog {}
       end
-      
+
       it "should execute javascript on the browser" do
         expect(selenium_browser).to receive(:execute_script).and_return("abc")
         expect(selenium_page_object.execute_script("333")).to eql "abc"
@@ -360,7 +388,7 @@ describe PageObject do
         expect(selenium_browser).to receive(:title).and_return("My Title")
         selenium_page_object.attach_to_window(:title => "My Title")
       end
-      
+
       it "should switch to a new window with a given url" do
         expect(selenium_browser).to receive(:window_handles).and_return(["win1"])
         expect(selenium_browser).to receive(:switch_to).twice.and_return(selenium_browser)
@@ -368,36 +396,36 @@ describe PageObject do
         expect(selenium_browser).to receive(:current_url).and_return("page.html")
         selenium_page_object.attach_to_window(:url => "page.html")
       end
-      
+
       it "should refresh the page contents" do
         expect(selenium_browser).to receive(:navigate).and_return(selenium_browser)
         expect(selenium_browser).to receive(:refresh)
         selenium_page_object.refresh
       end
-      
+
       it "should know how to go back" do
         expect(selenium_browser).to receive(:navigate).and_return(selenium_browser)
         expect(selenium_browser).to receive(:back)
         selenium_page_object.back
       end
-      
+
       it "should know how to go forward" do
         expect(selenium_browser).to receive(:navigate).and_return(selenium_browser)
         expect(selenium_browser).to receive(:forward)
         selenium_page_object.forward
       end
-      
+
       it "should know its' current url" do
         expect(selenium_browser).to receive(:current_url).and_return("cheezyworld.com")
         expect(selenium_page_object.current_url).to eql "cheezyworld.com"
       end
-      
+
       it "should clear all of the cookies from the browser" do
         expect(selenium_browser).to receive(:manage).and_return(selenium_browser)
         expect(selenium_browser).to receive(:delete_all_cookies)
         selenium_page_object.clear_cookies
       end
-      
+
       it "should be able to save a screenshot" do
         expect(selenium_browser).to receive(:save_screenshot)
         selenium_page_object.save_screenshot("test.png")

data/spec/page-object/page_section_spec.rb

@@ -53,7 +53,14 @@ describe PageObject::SectionCollection do
   ContainedItem = Struct.new(:type, :name)
   let(:section_collection) do
     contained_items = [ContainedItem.new(:sandwich, :reuben), ContainedItem.new(:soup, :lobster_bisque), ContainedItem.new(:sandwich, :dagwood)]
-    PageObject::SectionCollection.new(contained_items)
+    PageObject::SectionCollection[*contained_items]
+  end
+  it 'should inherit from Array' do
+    expect(PageObject::SectionCollection.superclass).to eq Array
+  end
+  it 'should have functioning array methods' do
+    expect(section_collection.methods).to include *Array.instance_methods
+    expect(section_collection.last.type).to eq :sandwich
   end
   it 'should be indexed to the sections' do
     expect(section_collection[0]).to be_an_instance_of ContainedItem
@@ -70,4 +77,4 @@ describe PageObject::SectionCollection do
   it 'should find all sections matching a value' do
     expect(section_collection.select_by(type: :sandwich).map(&:type)).to eq [:sandwich, :sandwich]
   end
-end
+end

data/spec/page-object/watir_accessors_spec.rb

@@ -284,6 +284,7 @@ describe PageObject::Accessors do
 
     def mock_driver_for(tag)
       expect(watir_browser).to receive(tag).with(:index => 0).and_return(watir_browser)
+      allow(watir_browser).to receive(:exists?).with(no_args)
     end
 
     it "should work with a text_field" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: page-object
 version: !ruby/object:Gem::Version
-  version: 1.1.1
+  version: 1.2.0
 platform: ruby
 authors:
 - Jeff Morgan
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-01-07 00:00:00.000000000 Z
+date: 2016-06-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: watir-webdriver
@@ -357,7 +357,7 @@ files:
 - lib/page-object/platforms/watir_webdriver/text_area.rb
 - lib/page-object/platforms/watir_webdriver/text_field.rb
 - lib/page-object/platforms/watir_webdriver/unordered_list.rb
-- lib/page-object/sections.rb
+- lib/page-object/section_collection.rb
 - lib/page-object/version.rb
 - lib/page-object/widgets.rb
 - page-object.gemspec
@@ -431,7 +431,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: page-object
-rubygems_version: 2.4.3
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Page Object DSL for browser testing

data/lib/page-object/sections.rb

@@ -1,29 +0,0 @@
-module PageObject
-  class SectionCollection
-    include Enumerable
-
-    def initialize sections
-      @sections = sections
-    end
-
-    def each &block
-      @sections.each &block
-    end
-
-    def [] index
-      @sections[index]
-    end
-
-    def find_by values_hash
-      @sections.find {|section|
-        values_hash.all? {|method,value| value === section.public_send(method)}
-      }
-    end
-
-    def select_by values_hash
-      SectionCollection.new @sections.select {|section|
-        values_hash.all? {|method,value| value === section.public_send(method)}
-      }
-    end
-  end
-end