page-object 1.2.0 → 1.2.1

data/spec/page-object/page_factory_spec.rb

@@ -1,238 +0,0 @@
-require 'spec_helper'
-require 'page-object/page_factory'
-
-class FactoryTestPage
-  include PageObject
-  page_url "http://google.com"
-end
-
-class TestPageWithDirectUrl
-  include PageObject
-  direct_url "http//google.com"
-end
-
-class AnotherPage
-  include PageObject
-end
-
-class YetAnotherPage
-  include PageObject
-end
-
-module ContainingModule
-  class PageInsideModule
-    include PageObject
-    page_url "http://google.co.uk"
-  end
-end
-
-class WorldSuper
-  attr_reader :super_called
-  def on_page(cls, params={}, visit=false, &block)
-    @super_called = true
-  end
-end
-
-
-class TestWorld < WorldSuper
-  include PageObject::PageFactory
-  attr_accessor :browser
-  attr_accessor :current_page
-end
-
-describe PageObject::PageFactory do
-  before(:each) do
-    @world = TestWorld.new
-    @world.browser = mock_watir_browser
-  end
-
-  it "should call super when non page-object class passed " do
-    class NoPO
-    end
-    @world.on(NoPO)
-    expect(@world.super_called).to be true
-  end
-
-  it "should create a new page object and execute a block" do
-    expect(@world.browser).not_to receive(:goto)
-    @world.on_page FactoryTestPage do |page|
-      expect(page).to be_instance_of FactoryTestPage
-    end
-    @world.on_page "FactoryTestPage" do |page|
-      expect(page).to be_instance_of FactoryTestPage
-    end
-    @world.on_page "ContainingModule::PageInsideModule" do |page|
-      expect(page).to be_instance_of ContainingModule::PageInsideModule
-    end
-  end
-
-  it "should create a new page object and execute a block using 'on'" do
-    expect(@world.browser).not_to receive(:goto)
-    @world.on FactoryTestPage do |page|
-      expect(page).to be_instance_of FactoryTestPage
-    end
-    @world.on "FactoryTestPage" do |page|
-      expect(page).to be_instance_of FactoryTestPage
-    end
-    @world.on "ContainingModule::PageInsideModule" do |page|
-      expect(page).to be_instance_of ContainingModule::PageInsideModule
-    end
-  end
-
-  it "should create and visit a new page" do
-    expect(@world.browser).to receive(:goto).exactly(3).times
-    @world.visit_page FactoryTestPage do |page|
-      expect(page).to be_instance_of FactoryTestPage
-    end
-    @world.visit_page "FactoryTestPage" do |page|
-      expect(page).to be_instance_of FactoryTestPage
-    end
-    @world.visit_page "ContainingModule::PageInsideModule" do |page|
-      expect(page).to be_instance_of ContainingModule::PageInsideModule
-    end
-  end
-
-  it "should merge params with the class level params if provided when visiting" do
-    expect(@world.browser).to receive(:goto)
-    FactoryTestPage.params = {:initial => :value}
-    @world.visit_page(FactoryTestPage, :using_params => {:new_value => :merged})
-    merged = FactoryTestPage.instance_variable_get("@merged_params")
-    expect(merged[:initial]).to eql :value
-    expect(merged[:new_value]).to eql :merged
-  end
-
-  it "should use the params in the url when they are provided" do
-    class PageUsingParams
-      include PageObject
-      page_url "http://google.com/<%=params[:value]%>"
-    end
-    expect(@world.browser).to receive(:goto).with("http://google.com/PageObject")
-    @world.visit_page(PageUsingParams, :using_params => {:value => 'PageObject'})
-  end
-
-  it "should use the params as well as interpolated values" do
-    class PageUsingParmsAndInterpolated
-      include PageObject
-      page_url "http://google.com/#{1+2}/<%=params[:value]%>"
-    end
-    expect(@world.browser).to receive(:goto).with("http://google.com/3/PageObject")
-    @world.visit_page(PageUsingParmsAndInterpolated, :using_params => {:value => 'PageObject'})
-  end
-
-  it "should create and visit a new page using 'visit'" do
-    expect(@world.browser).to receive(:goto).exactly(3).times
-    @world.visit FactoryTestPage do |page|
-      expect(page).to be_instance_of FactoryTestPage
-    end
-    @world.visit "FactoryTestPage" do |page|
-      expect(page).to be_instance_of FactoryTestPage
-    end
-    @world.visit "ContainingModule::PageInsideModule" do |page|
-      expect(page).to be_instance_of ContainingModule::PageInsideModule
-    end
-  end
-
-  it "should create and visit a new page when url is defined as 'direct_url'" do
-    expect(@world.browser).to receive(:goto)
-    @world.visit TestPageWithDirectUrl do |page|
-      expect(page).to be_instance_of TestPageWithDirectUrl
-    end
-  end
-  
-  it "should set an instance variable that can be used outside of the block" do
-    page = @world.on_page FactoryTestPage
-    current_page = @world.instance_variable_get "@current_page"
-    expect(current_page).to equal page
-  end
-
-  it "should not execute block if page is not @current_page" do
-    @world.instance_variable_set "@current_page", TestPageWithDirectUrl.new(@world.browser)
-    @world.if_page(FactoryTestPage) do |page|
-      fail
-    end
-    @world.if_page("FactoryTestPage") do |page|
-      fail
-    end
-    @world.if_page("ContainingModule::PageInsideModule") do |page|
-      fail
-    end
-  end
-
-  it "should return the @current_page if asking for another page" do
-    expected = TestPageWithDirectUrl.new(@world.browser)
-    @world.instance_variable_set "@current_page", expected
-    expect(@world.if_page(FactoryTestPage)).to eql expected
-    expect(@world.if_page("FactoryTestPage")).to eql expected
-    expect(@world.if_page("ContainingModule::PageInsideModule")).to eql expected
-  end
-
-  it "should execute the block when we ask if it is the correct page" do
-    @world.instance_variable_set "@current_page", FactoryTestPage.new(@world.browser)
-    
-    done = false
-    @world.if_page(FactoryTestPage) do |page|
-      expect(page).to be_instance_of FactoryTestPage
-      done = true 
-    end
-    expect(done).to be true
-    
-    done = false
-    @world.if_page("FactoryTestPage") do |page|
-      expect(page).to be_instance_of FactoryTestPage
-      done = true
-    end
-    expect(done).to be true
-    
-    done = false
-    @world.instance_variable_set "@current_page", ContainingModule::PageInsideModule.new(@world.browser) 
-    @world.if_page("ContainingModule::PageInsideModule") do |page|
-      expect(page).to be_instance_of ContainingModule::PageInsideModule
-      done = true
-    end
-    expect(done).to be true
-  end
-
-  it "should raise an error when you do not provide a default route" do
-    expect { PageObject::PageFactory.routes = {:another => []} }.to raise_error
-  end
-
-  it "should store the routes" do
-    routes = ['a', 'b', 'c']
-    PageObject::PageFactory.routes = {:default => routes}
-    expect(PageObject::PageFactory.routes[:default]).to eql routes
-  end
-
-  it "should navigate to a page calling the default methods" do
-    pages = [[FactoryTestPage, :a_method], [AnotherPage, :b_method]]
-    PageObject::PageFactory.routes = {:default => pages}
-    fake_page = double('a_page')
-    expect(FactoryTestPage).to receive(:new).and_return(fake_page)
-    expect(fake_page).to receive(:a_method)
-    expect(@world.navigate_to(AnotherPage).class).to eql AnotherPage
-  end
-
-  it "should pass parameters to methods when navigating" do
-    pages = [[FactoryTestPage, :a_method, 'blah'], [AnotherPage, :b_method]]
-    PageObject::PageFactory.routes = {:default => pages}
-    fake_page = double('a_page')
-    expect(FactoryTestPage).to receive(:new).and_return(fake_page)
-    expect(fake_page).to receive(:a_method).with('blah')
-    expect(@world.navigate_to(AnotherPage).class).to eql AnotherPage
-  end
-
-  it "should fail when it does not find a proper route" do
-    PageObject::PageFactory.routes = {:default => ['a'], :another => ['b']}
-    expect { @world.navigate_to(AnotherPage, :using => :no_route) }.to raise_error
-  end
-
-  it "should fail when no default method specified" do
-    PageObject::PageFactory.routes = {
-      :default => [[FactoryTestPage, :a_method], [AnotherPage, :b_method]]
-    }
-    fake_page = double('a_page')
-    expect(FactoryTestPage).to receive(:new).and_return(fake_page)
-    expect(fake_page).to receive(:respond_to?).with(:a_method).and_return(false)
-    expect { @world.navigate_to(AnotherPage) }.to raise_error
-  end
-
-end

data/spec/page-object/page_populator_spec.rb

@@ -1,122 +0,0 @@
-require 'spec_helper'
-
-class PageObjectTestPageObject
-  include PageObject
-
-  text_field(:tf, :id => 'id')
-  text_area(:ta, :id => 'id')
-  select_list(:sl, :id => 'id')
-  file_field(:ff, :id => 'id')
-  checkbox(:cb, :id => 'id')
-  radio_button(:rb, :id => 'id')
-  radio_button_group(:rbg, :id => 'id')
-end
-
-describe PageObject::PagePopulator  do
-  let(:browser) { mock_watir_browser }
-  let(:page_object) { PageObjectTestPageObject.new(browser) }
-
-  it "should set a value in a text field" do
-    expect(page_object).to receive(:tf=).with('value')
-    allow(page_object).to receive(:is_enabled?).and_return(true)
-    page_object.populate_page_with('tf' => 'value')
-  end
-
-  it "should not set a value in a text field if it is not found on the page" do
-    expect(browser).not_to receive(:text_field)
-    page_object.populate_page_with('coffee' => 'value')
-  end
-
-  it "should not populate a text field when it is disabled" do
-    expect(page_object).not_to receive(:tf=)
-    expect(page_object).to receive(:tf_element).twice.and_return(browser)
-    expect(browser).to receive(:enabled?).and_return(false)
-    expect(browser).to receive(:tag_name).and_return('input')
-    page_object.populate_page_with('tf' => true)
-  end
-
-  it "should not populate a text field when it is not visible" do
-    expect(page_object).not_to receive(:tf=)
-    expect(page_object).to receive(:tf_element).twice.and_return(browser)
-    expect(browser).to receive(:enabled?).and_return(true)
-    expect(browser).to receive(:visible?).and_return(false)
-    expect(browser).to receive(:tag_name).and_return('input')
-    page_object.populate_page_with('tf' => true)
-  end
-
-  it "should set a value in a text area" do
-    expect(page_object).to receive(:ta=).with('value')
-    expect(page_object).to receive(:ta_element).and_return(browser)
-    expect(browser).to receive(:tag_name).and_return('textarea')
-    page_object.populate_page_with('ta' => 'value')
-  end
-
-  it "should set a value in a select list" do
-    expect(page_object).to receive(:sl=).with('value')
-    allow(page_object).to receive(:is_enabled?).and_return(true)
-    page_object.populate_page_with('sl' => 'value')
-  end
-
-  it "should set a value in a file field" do
-    expect(page_object).to receive(:ff=).with('value')
-    allow(page_object).to receive(:is_enabled?).and_return(true)
-    page_object.populate_page_with('ff' => 'value')
-  end
-
-  it "should check a checkbox to true is specified" do
-    expect(page_object).to receive(:check_cb)
-    allow(page_object).to receive(:is_enabled?).and_return(true)
-    page_object.populate_page_with('cb' => true)
-  end
-
-  it "should uncheck a checkbox to false is specified" do
-    expect(page_object).to receive(:uncheck_cb)
-    allow(page_object).to receive(:is_enabled?).and_return(true)
-    page_object.populate_page_with('cb' => false)
-  end
-
-  it "should select a radio button when true is specified" do
-    expect(page_object).to receive(:select_rb)
-    allow(page_object).to receive(:is_enabled?).and_return(true)
-    page_object.populate_page_with('rb' => true)
-  end
-
-  it "should select the correct element from a radio button group" do
-    expect(page_object).to receive(:select_rbg).with('blah')
-    page_object.populate_page_with('rbg' => 'blah')
-  end
-
-  it "should not populate a checkbox if it is disabled" do
-    expect(page_object).not_to receive(:check_cb)
-    expect(page_object).to receive(:cb_element).twice.and_return(browser)
-    expect(browser).to receive(:enabled?).and_return(false)
-    expect(browser).to receive(:tag_name).and_return('input')
-    page_object.populate_page_with('cb' => true)
-  end
-
-  it "should not populate a checkbox if it is not visible" do
-    expect(page_object).not_to receive(:check_cb)
-    expect(page_object).to receive(:cb_element).twice.and_return(browser)
-    expect(browser).to receive(:enabled?).and_return(true)
-    expect(browser).to receive(:visible?).and_return(false)
-    expect(browser).to receive(:tag_name).and_return('input')
-    page_object.populate_page_with('cb' => true)
-  end
-
-  it "should not populate a radio button when it is disabled" do
-    expect(page_object).not_to receive(:select_rb)
-    expect(page_object).to receive(:rb_element).twice.and_return(browser)
-    expect(browser).to receive(:enabled?).and_return(false)
-    expect(browser).to receive(:tag_name).and_return('input')
-    page_object.populate_page_with('rb' => true)
-  end
-
-  it "should not populate a radio button when it is not visible" do
-    expect(page_object).not_to receive(:select_rb)
-    expect(page_object).to receive(:rb_element).twice.and_return(browser)
-    expect(browser).to receive(:enabled?).and_return(true)
-    expect(browser).to receive(:visible?).and_return(false)
-    expect(browser).to receive(:tag_name).and_return('input')
-    page_object.populate_page_with('rb' => true)
-  end
-end

data/spec/page-object/page_section_spec.rb

@@ -1,80 +0,0 @@
-require 'spec_helper'
-require 'page-object/elements'
-
-class Container
-  include PageObject
-end
-class SectionsPage
-  include PageObject
-
-  page_section(:container, Container, :id => 'blah')
-  page_sections(:containers, Container, :class => 'foo')
-end
-
-describe PageObject::Accessors do
-  context 'when using watir' do
-    let(:watir_browser) { mock_watir_browser }
-    let(:watir_page_object) { SectionsPage.new(watir_browser) }
-
-    it 'it should find a page section' do
-      expect(watir_browser).to receive(:element).with(:id => 'blah').and_return(watir_browser)
-      section = watir_page_object.container
-      expect(section).to be_instance_of Container
-    end
-    it 'it should find page sections' do
-      expect(watir_browser).to receive(:elements).with(:class => 'foo').and_return([watir_browser, watir_browser])
-      sections = watir_page_object.containers
-      expect(sections).to be_instance_of(PageObject::SectionCollection)
-      sections.each do |section|
-        expect(section).to be_instance_of(Container)
-      end
-    end
-  end
-  context 'when using selenium' do
-    let(:selenium_browser) { mock_selenium_browser }
-    let(:selenium_page_object) { SectionsPage.new(selenium_browser) }
-
-    it 'it should find a page section' do
-      expect(selenium_browser).to receive(:find_element).with(:id, 'blah').and_return(selenium_browser)
-      section = selenium_page_object.container
-      expect(section).to be_instance_of Container
-    end
-    it 'it should find page sections' do
-      expect(selenium_browser).to receive(:find_elements).with(:class, 'foo').and_return([selenium_browser, selenium_browser])
-      sections = selenium_page_object.containers
-      expect(sections).to be_instance_of(PageObject::SectionCollection)
-      sections.each do |section|
-        expect(section).to be_instance_of(Container)
-      end
-    end
-  end
-end
-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[*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
-    expect(section_collection[-1]).to be_an_instance_of ContainedItem
-  end
-  it 'should be able to iterate over the sections' do
-    section_collection.each do |section|
-      expect(section).to be_an_instance_of ContainedItem
-    end
-  end
-  it 'should find a section by one of its values' do
-    expect(section_collection.find_by(name: :dagwood).name).to eq :dagwood
-  end
-  it 'should find all sections matching a value' do
-    expect(section_collection.select_by(type: :sandwich).map(&:type)).to eq [:sandwich, :sandwich]
-  end
-end

data/spec/page-object/platforms/selenium_webdriver/selenium_page_object_spec.rb

@@ -1,68 +0,0 @@
-require 'spec_helper'
-require 'page-object/platforms/selenium_webdriver/page_object'
-require 'page-object/elements'
-
-class SeleniumTestPageObject
-  include PageObject
-end
-
-describe PageObject::Platforms::SeleniumWebDriver::PageObject do
-  let(:selenium_browser) { mock_selenium_browser }
-  let(:selenium_page_object) { SeleniumTestPageObject.new(selenium_browser) }
-  
-  before(:each) do
-    allow(selenium_browser).to receive(:switch_to).and_return(selenium_browser)
-    allow(selenium_browser).to receive(:default_content)
-  end
-
-  context "when building identifiers hash" do
-    it "should add tag_name when identifying by text for hidden_field" do
-      expected_identifier = {:text => 'foo', :tag_name => 'input', :type => 'hidden'}
-      expect(PageObject::Elements::HiddenField).to receive(:selenium_identifier_for).with(expected_identifier)
-      expect(selenium_browser).to receive(:find_element)
-      selenium_page_object.platform.hidden_field_for(:text => 'foo')
-    end
-
-    it "should add tag_name when identifying by href for anchor" do
-      expected_identifier = {:href => 'foo', :tag_name => 'a'}
-      expect(PageObject::Elements::Link).to receive(:selenium_identifier_for).with(expected_identifier)
-      expect(selenium_browser).to receive(:find_element)
-      selenium_page_object.platform.link_for(:href => 'foo')
-    end
-    
-    it "should add tag_name when identifying by text for div" do
-      expected_identifier = {:text => 'foo', :tag_name => 'div'}
-      expect(PageObject::Elements::Div).to receive(:selenium_identifier_for).with(expected_identifier)
-      expect(selenium_browser).to receive(:find_element)
-      selenium_page_object.platform.div_for(:text => 'foo')
-    end
-  end
-
-  context "when trying to find an element that does not exist" do
-    it "should return a surogate selenium object" do
-      expect(selenium_browser).to receive(:find_element).and_raise(Selenium::WebDriver::Error::NoSuchElementError)
-      page = SeleniumTestPageObject.new(selenium_browser)
-      element = page.link_element(:text => 'blah')
-      expect(element.element).to be_instance_of PageObject::Platforms::SeleniumWebDriver::SurrogateSeleniumElement
-    end
-
-    it "should know it is not exist" do
-      expect(selenium_browser).to receive(:find_element).twice.and_raise(Selenium::WebDriver::Error::NoSuchElementError)
-      page = SeleniumTestPageObject.new(selenium_browser)
-      expect(page.link_element(:text => 'blah').element.exists?).to be false
-    end
-
-    it "should know it is not visible" do
-      expect(selenium_browser).to receive(:find_element).twice.and_raise(Selenium::WebDriver::Error::NoSuchElementError)
-      page = SeleniumTestPageObject.new(selenium_browser)
-      expect(page.link_element(:text => 'blah').element).not_to be_visible
-    end
-
-    it "should raise an error when actions are requested" do
-      expect(selenium_browser).to receive(:find_element).and_raise(Selenium::WebDriver::Error::NoSuchElementError)
-      page = SeleniumTestPageObject.new(selenium_browser)
-      element = page.link_element(:text => 'blah')
-      expect { element.text }.to raise_error
-    end
-  end
-end