page-object 0.0.1

data/page-object.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "page-object/version"
+
+Gem::Specification.new do |s|
+  s.name        = "page-object"
+  s.version     = PageObject::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Jeff Morgan"]
+  s.email       = ["jeff.morgan@leandog.com"]
+  s.homepage    = "http://github.com/cheezy/page-object"
+  s.summary     = %q{Page Object DSL for browser testing}
+  s.description = %q{Page Object DSL that works with both Watir and Selenium}
+
+  s.rubyforge_project = "page-object"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency 'watir-webdriver', '>= 0.2.3'
+  s.add_dependency 'selenium-webdriver', '>= 0.2.0' 
+  
+  s.add_development_dependency 'rspec', '>= 2.5.0'
+  s.add_development_dependency 'cucumber', '>= 0.10.2'
+  s.add_development_dependency 'yard', '>= 0.6.8'
+  
+end

data/spec/page-object/accessors_spec.rb

@@ -0,0 +1,297 @@
+require 'spec_helper'
+
+class TestPageObject
+  include PageObject
+
+  link(:google_search, {:link => 'Google Search'})
+  text_field(:first_name, {:id => 'first_name'})
+  select_list(:state, {:id => 'state'})
+  checkbox(:active, {:id => 'is_active_id'})
+  radio_button(:first, {:id => 'first_choice'})
+  button(:click_me, { :id => 'button_submit'})
+end
+
+describe PageObject::Accessors do
+  let(:watir_browser) { mock_watir_browser }
+  let(:selenium_browser) { mock_selenium_browser }
+  let(:watir_page_object) { TestPageObject.new(watir_browser) }
+  let(:selenium_page_object) { TestPageObject.new(selenium_browser) }
+  
+  describe "link accessors" do
+    context "when called on a page object" do
+      it "should generate accessor methods" do
+        watir_page_object.should respond_to(:google_search)
+        watir_page_object.should respond_to(:google_search_link)
+      end
+    end
+
+    context "Watir implementation" do
+      it "should select a link" do
+        watir_browser.stub_chain(:link, :click)
+        watir_page_object.google_search
+      end
+      
+      it "should return a link element" do
+        watir_browser.should_receive(:link).and_return(watir_browser)
+        element = watir_page_object.google_search_link
+        element.should be_instance_of PageObject::Elements::Link
+      end
+    end
+
+    context "Selenium implementation" do
+      it "should select a link" do
+        selenium_browser.stub_chain(:find_element, :click)
+        selenium_page_object.google_search
+      end
+      
+      it "should return a link element" do
+        selenium_browser.should_receive(:find_element).and_return(selenium_browser)
+        element = selenium_page_object.google_search_link
+        element.should be_instance_of PageObject::Elements::Link
+      end
+    end
+  end
+
+
+  describe "text_field accessors" do
+    context "when called on a page object" do
+      it "should generate accessor methods" do
+        watir_page_object.should respond_to(:first_name)
+        watir_page_object.should respond_to(:first_name=)
+        watir_page_object.should respond_to(:first_name_text_field)
+      end
+    end
+
+    context "Watir implementation" do
+      it "should get the text from the text field element" do
+        watir_browser.should_receive(:text_field).and_return(watir_browser)
+        watir_browser.should_receive(:value).and_return('Kim')
+        watir_page_object.first_name.should == 'Kim'
+      end
+    
+      it "should set some text on a text field element" do
+        watir_browser.should_receive(:text_field).and_return(watir_browser)
+        watir_browser.should_receive(:set).with('Kim')
+        watir_page_object.first_name = 'Kim'
+      end
+      
+      it "should retrieve a text field element" do
+        watir_browser.should_receive(:text_field).and_return(watir_browser)
+        element = watir_page_object.first_name_text_field
+        element.should be_instance_of PageObject::Elements::TextField
+      end
+    end
+
+    context "Selenium implementation" do
+      it "should get the text from the text field element" do
+        selenium_browser.should_receive(:find_element).and_return(selenium_browser)
+        selenium_browser.should_receive(:value).and_return('Katie')
+        selenium_page_object.first_name.should == 'Katie'
+      end
+
+      it "should set some text on a text field element" do
+        selenium_browser.should_receive(:find_element).and_return(selenium_browser)
+        selenium_browser.should_receive(:send_keys).with('Katie')
+        selenium_page_object.first_name = 'Katie'
+      end
+      
+      it "should should retrieve a text field element" do
+        selenium_browser.should_receive(:find_element).and_return(selenium_browser)
+        element = selenium_page_object.first_name_text_field
+        element.should be_instance_of PageObject::Elements::TextField
+      end
+    end
+  end
+  
+  
+  describe "select_list accessors" do
+    context "when called on a page object" do
+      it "should generate accessor methods" do
+        watir_page_object.should respond_to :state
+        watir_page_object.should respond_to :state=
+        watir_page_object.should respond_to(:state_select_list)
+      end
+    end
+  
+    context "Watir implementation" do
+      it "should get the current item from a select list" do
+        watir_browser.should_receive(:select_list).and_return watir_browser
+        watir_browser.should_receive(:value).and_return("OH")
+        watir_page_object.state.should == "OH"
+      end
+    
+      it "should set the current item of a select list" do
+        watir_browser.should_receive(:select_list).and_return watir_browser
+        watir_browser.should_receive(:select).with("OH")
+        watir_page_object.state = "OH"
+      end
+      
+      it "should retreive the select list element" do
+        watir_browser.should_receive(:select_list).and_return(watir_browser)
+        element = watir_page_object.state_select_list
+        element.should be_instance_of PageObject::Elements::SelectList
+      end
+    end
+  
+    context "Selenium implementation" do
+      it "should should get the current item from a select list" do
+        selenium_browser.should_receive(:find_element).and_return(selenium_browser)
+        selenium_browser.should_receive(:attribute).and_return("OH")
+        selenium_page_object.state.should == "OH"
+      end
+    
+      it "should set the current item of a select list" do
+        selenium_browser.should_receive(:find_element).and_return(selenium_browser)
+        selenium_browser.should_receive(:send_keys).with("OH")
+        selenium_page_object.state = "OH"
+      end
+      
+      it "should retrieve the select list element" do
+        selenium_browser.should_receive(:find_element).and_return(selenium_browser)
+        element = selenium_page_object.state_select_list
+        element.should be_instance_of PageObject::Elements::SelectList
+      end
+    end
+  end
+
+  
+  describe "check_box accessors" do
+    context "when called on a page object" do
+      it "should generate accessor methods" do
+        watir_page_object.should respond_to :check_active
+        watir_page_object.should respond_to :uncheck_active
+        watir_page_object.should respond_to :active_checked?
+        watir_page_object.should respond_to(:active_checkbox)
+      end
+    end
+
+    context "Watir implementation" do
+      it "should check a check box element" do
+        watir_browser.should_receive(:checkbox).and_return(watir_browser)
+        watir_browser.should_receive(:set)
+        watir_page_object.check_active
+      end
+
+      it "should clear a check box element" do
+        watir_browser.should_receive(:checkbox).and_return(watir_browser)
+        watir_browser.should_receive(:clear)
+        watir_page_object.uncheck_active
+      end
+
+      it "should know if a check box element is selected" do
+        watir_browser.should_receive(:checkbox).and_return(watir_browser)
+        watir_browser.should_receive(:set?).and_return(true)
+        watir_page_object.active_checked?.should be_true
+      end
+      
+      it "should retrieve a checkbox element" do
+        watir_browser.should_receive(:checkbox).and_return(watir_browser)
+        element = watir_page_object.active_checkbox
+        element.should be_instance_of PageObject::Elements::CheckBox
+      end
+    end
+
+    context "Selenium implementation" do
+      it "should check a check box element" do
+        selenium_browser.should_receive(:find_element).twice.and_return(selenium_browser)
+        selenium_browser.should_receive(:selected?).and_return(false)
+        selenium_browser.should_receive(:toggle)
+        selenium_page_object.check_active
+      end
+    
+      it "should clear a check box element" do
+        selenium_browser.should_receive(:find_element).twice.and_return(selenium_browser)
+        selenium_browser.should_receive(:selected?).and_return(true)
+        selenium_browser.should_receive(:toggle)
+        selenium_page_object.uncheck_active
+      end
+    
+      it "should know if a check box element is selected" do
+        selenium_browser.should_receive(:find_element).and_return(selenium_browser)
+        selenium_browser.should_receive(:selected?).and_return(true)
+        selenium_page_object.active_checked?.should be_true
+      end
+      
+      it "should retrieve a checkbox element" do
+        selenium_browser.should_receive(:find_element).and_return(selenium_browser)
+        element = selenium_page_object.active_checkbox
+        element.should be_instance_of PageObject::Elements::CheckBox
+      end
+    end
+  end
+  
+  
+  describe "radio accessors" do
+    context "when called on a page object" do
+      it "should generate accessor methods" do
+        watir_page_object.should respond_to :select_first
+        watir_page_object.should respond_to :clear_first
+        watir_page_object.should respond_to :first_selected?
+        watir_page_object.should respond_to(:first_radio_button)
+      end
+    end
+
+    context "Watir implementation" do
+      it "should select a radio button" do
+        watir_browser.should_receive(:radio).and_return(watir_browser)
+        watir_browser.should_receive(:set)
+        watir_page_object.select_first
+      end
+      
+      it "should clear a radio button" do
+        watir_browser.should_receive(:radio).and_return(watir_browser)
+        watir_browser.should_receive(:clear)
+        watir_page_object.clear_first
+      end
+      
+      it "should determine if a radio is selected" do
+        watir_browser.should_receive(:radio).and_return(watir_browser)
+        watir_browser.should_receive(:set?)
+        watir_page_object.first_selected?
+      end
+      
+      it "should retrieve a radio button element" do
+        watir_browser.should_receive(:radio).and_return(watir_browser)
+        element = watir_page_object.first_radio_button
+        element.should be_instance_of PageObject::Elements::RadioButton
+      end
+    end
+
+    context "Selenium implementation" do
+      it "should select a radio button" do
+        selenium_browser.should_receive(:find_element).twice.and_return(selenium_browser)
+        selenium_browser.should_receive(:selected?).and_return(false)
+        selenium_browser.should_receive(:click)
+        selenium_page_object.select_first
+      end
+      
+      it "should clear a radio button" do
+        selenium_browser.should_receive(:find_element).twice.and_return(selenium_browser)
+        selenium_browser.should_receive(:selected?).and_return(true)
+        selenium_browser.should_receive(:click)
+        selenium_page_object.clear_first
+      end
+
+      it "should determine if a radio is selected" do
+        selenium_browser.should_receive(:find_element).and_return(selenium_browser)
+        selenium_browser.should_receive(:selected?).and_return(true)
+        selenium_page_object.first_selected?
+      end
+      
+      it "should retrieve a radio button element" do
+        selenium_browser.should_receive(:find_element).and_return(selenium_browser)
+        element = selenium_page_object.first_radio_button
+        element.should be_instance_of PageObject::Elements::RadioButton
+      end
+    end
+  end
+
+  describe "button accessors" do
+    context "when called on a page object" do
+      it "should generate accessor methods" do
+        watir_page_object.should respond_to :click_me
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,23 @@
+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, :xpath].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, :name, :xpath].each do |t|
+        key, value = button.selenium_identifier_for t => 'value'
+        key.should == t
+      end
+    end
+  end
+
+end

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

@@ -0,0 +1,21 @@
+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].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].each do |t|
+        key, value = checkbox.selenium_identifier_for t => 'value'
+        key.should == t
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+require 'spec_helper'
+require 'page-object/elements'
+
+
+describe PageObject::Elements::Element do
+  let(:watir_driver) { double('watir') }
+  let(:selenium_driver) { double('selenium') }
+  let(:watir_element) { PageObject::Elements::Element.new(watir_driver, :platform => :watir) }
+  let(:selenium_element) { PageObject::Elements::Element.new(selenium_driver, :platform => :selenium) }
+
+  context "on a Watir page-object" do
+    it "should know when it is visible" do
+      watir_driver.should_receive(:present?).and_return(true)
+      watir_element.visible?.should == true
+    end
+    
+    it "should know when it is not visible" do
+      watir_driver.should_receive(:present?).and_return(false)
+      watir_element.visible?.should == false
+    end
+    
+    it "should know when it exists" do
+      watir_driver.should_receive(:exists?).and_return(true)
+      watir_element.exists?.should == true
+    end
+    
+    it "should know when it does not exist" do
+      watir_driver.should_receive(:exists?).and_return(false)
+      watir_element.exists?.should == false
+    end
+  end
+  
+  context "on a Selenium page-object" do
+    it "should know when it is visible" do
+      selenium_driver.should_receive(:displayed?).and_return(true)
+      selenium_element.visible?.should == true
+    end
+    
+    it "should know when it is not visible" do
+      selenium_driver.should_receive(:displayed?).and_return(false)
+      selenium_element.visible?.should == false
+    end
+    
+    it "should know when it exists" do
+      selenium_element.exists?.should == true      
+    end
+    
+    it "should know when it does not exist" do
+      selenium_element = PageObject::Elements::Element.new(nil, :platform => :selenium)
+      selenium_element.exists?.should == false
+      
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+require 'spec_helper'
+require 'page-object/elements'
+
+describe PageObject::Elements::Link do
+  let(:link) { PageObject::Elements::Link }
+  
+  describe "when mapping how to find an element" do
+    it "should map watir types to same" do
+      [:class, :href, :id, :index, :name, :text, :xpath].each do |t|
+        identifier = link.watir_identifier_for t => 'value'
+        identifier.keys.first.should == t
+      end
+    end
+    
+    it "should map selenium types to watir" do
+      [:link, :link_text].each do |t|
+        identifier = link.watir_identifier_for t => 'value'
+        identifier.keys.first.should == :text
+      end
+    end
+    
+    it "should map selenium types to same" do
+      [:class, :id, :link, :link_text, :name, :xpath].each do |t|
+        key, value = link.selenium_identifier_for t => 'value'
+        key.should == t
+      end
+    end
+    
+    it "should map watir types to selenium" do
+      key, value = link.selenium_identifier_for :text => 'value'
+      key.should == :link_text
+    end
+  end
+end