page-object 0.0.1

data/features/step_definitions/element_steps.rb

@@ -0,0 +1,28 @@
+When /^I retrieve a check box element$/ do
+  @element = @page.cb_id_checkbox
+end
+
+When /^I retrieve a link element$/ do
+  @element = @page.google_search_id_link
+end
+
+When /^I retrieve a radio button$/ do
+  @element = @page.milk_id_radio_button
+end
+
+When /^I retrieve a select list$/ do
+  @element = @page.sel_list_id_select_list
+end
+
+When /^I retrieve a text field$/ do
+  @element = @page.text_field_id_text_field
+end
+
+Then /^I should know it exists$/ do
+  @element.should exist
+end
+
+Then /^I should know it is visible$/ do
+  @element.should be_visible
+end
+

data/features/step_definitions/page_level_actions_steps.rb

@@ -0,0 +1,12 @@
+
+Then /^the page should contain the text "([^\"]*)"$/ do |text|
+  @page.text.should include text  
+end
+
+Then /^the page should contain the html "([^\"]*)"$/ do |html|
+  @page.html.should include html
+end
+
+Then /^the page should have the title "([^\"]*)"$/ do |title|
+  @page.title.should include title
+end

data/features/step_definitions/page_traversal_steps.rb

@@ -0,0 +1,5 @@
+
+Given /^I am on the static elements page$/ do
+  @page = Page.new(@browser)
+  @page.navigate_to(UrlHelper.static_elements)
+end

data/features/support/env.rb

@@ -0,0 +1,18 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '../../', 'lib'))
+
+require 'rspec/expectations'
+require 'watir-webdriver'
+require 'selenium-webdriver'
+
+require 'page-object'
+
+Before do
+  @browser = Watir::Browser.new :firefox if ENV['DRIVER'] == 'WATIR'
+  @browser = Selenium::WebDriver.for :firefox if ENV['DRIVER'] == 'SELENIUM'
+end
+
+After do |s|
+  @browser.close
+end
+
+

data/features/support/page.rb

@@ -0,0 +1,45 @@
+class Page
+  include PageObject
+
+  text_field(:text_field_id, :id => "text_field_id")
+  text_field(:text_field_class, :class => "text_field_class")
+  text_field(:text_field_name, :name => "text_field_name")
+  text_field(:text_field_xpath, :xpath => "//input[@type='text']")
+  text_field(:text_field_css, :css => "input[type='text']")
+  text_field(:text_field_tag_name, :tag_name => "input[type='text']")
+  text_field(:text_field_index, :index => 0)
+  text_field(:text_field_text, :text => "")
+  text_field(:text_field_value, :value => "")
+
+  link(:google_search_id, :id => "link_id")
+  link(:google_search_name, :name => "link_name")
+  link(:google_search_class, :class => "link_class")
+  link(:google_search_xpath, :xpath => "//a[text()='Google Search']")
+  link(:google_search_link, :link => "Google Search")
+  link(:google_search_link_text, :link_text => "Google Search")
+  link(:google_search_href, :href => "http://www.google.com")
+  link(:google_search_text, :text => "Google Search")
+  link(:google_search_index, :index => 0)
+  
+  select_list(:sel_list_id, :id => "sel_list_id")
+  select_list(:sel_list_class, :class => "sel_list_class")
+  select_list(:sel_list_index, :index => 0)
+  select_list(:sel_list_name, :name => "sel_list_name")
+  select_list(:sel_list_value, :value => "option1")
+  select_list(:sel_list_xpath, :xpath => "//select")
+  select_list(:sel_list_text, :text => "Test 1")
+
+  checkbox(:cb_id, :id => 'cb_id')
+  checkbox(:cb_name, :name => 'cb_name')
+  checkbox(:cb_class, :class => 'cb_class')
+  checkbox(:cb_index, :index => 0)
+  checkbox(:cb_xpath, :xpath => "//input[@type='checkbox']")
+
+  radio_button(:milk_id, :id => 'milk_id')
+  radio_button(:milk_name, :name => 'milk_name')
+  radio_button(:milk_class, :class => 'milk_class')
+  radio_button(:milk_index, :index => 0)
+  radio_button(:milk_xpath, :xpath => "//input[@type='radio']")
+  
+  radio_button(:butter_id, :id => 'butter_id')
+end

data/features/support/url_helper.rb

@@ -0,0 +1,16 @@
+module UrlHelper
+  class << self
+    def html
+      File.expand_path("#{File.dirname(__FILE__)}/../html")
+    end
+
+    def files
+      "file://#{html}"
+    end
+
+
+    def static_elements
+      "#{files}/static_elements.html"
+    end
+  end
+end

data/features/text_field.feature

@@ -0,0 +1,39 @@
+Feature: Text Fields
+  In order to interact with text fields
+  Testers will need access and interrogation ability
+
+  
+  Background:
+    Given I am on the static elements page
+  
+  Scenario: Setting and getting a value from a text field
+    When I type "abcDEF" into the text field
+    Then the text field should contain "abcDEF"
+
+  Scenario Outline: Locating text fields on the Page
+    When I search for the text field by "<search_by>"
+    Then I should be able to type "I found it" into the field
+
+  Scenarios:
+    | search_by |
+    | id        |
+    | class     |
+    | name      |
+    | xpath     |  
+    | css       |
+    | tag_name  |
+
+  @watir_only
+  Scenario Outline: Locating text fields on Watir only
+    When I search for the text field by "<search_by>"
+
+  Scenarios:
+    | search_by |
+    | index     |
+    | text      |
+    | value     |
+
+  Scenario: Retrieve a text field
+    When I retrieve a text field
+    Then I should know it exists
+    And I should know it is visible

data/lib/page-object.rb

@@ -0,0 +1,52 @@
+
+require 'page-object/version'
+require 'page-object/accessors'
+
+# Module that when included adds core functionality to a page object.
+module PageObject
+  attr_reader :platform
+
+  # Construct a new page object.  The browser parameter must be either a
+  # Watir::Browser or Selenium::WebDriver::Driver.
+  def initialize(browser)
+    include_platform_driver(browser)
+  end
+
+  def self.included(cls)
+    cls.extend PageObject::Accessors
+  end
+  
+  # navigate to the provided url
+  def navigate_to(url)
+    platform.navigate_to(url)
+  end
+  
+  # Returns the text of the current page
+  def text
+    platform.text
+  end
+
+  # Returns the html of the current page
+  def html
+    platform.html
+  end
+
+  # Returns the title of the current page
+  def title
+    platform.title
+  end
+
+  private
+
+  def include_platform_driver(browser)
+    if browser.is_a? Watir::Browser
+      require 'page-object/watir_page_object'
+      @platform = PageObject::WatirPageObject.new(browser)
+    elsif browser.is_a? Selenium::WebDriver::Driver
+      require 'page-object/selenium_page_object'
+      @platform = PageObject::SeleniumPageObject.new(browser)
+    else
+      raise ArgumentError, "expect Watir::Browser or Selenium::WebDriver::Driver"
+    end
+  end
+end

data/lib/page-object/accessors.rb

@@ -0,0 +1,171 @@
+
+#
+# Contains the class level methods that are inserted into your page objects
+# when you include the PageObject module.  These methods will generate another
+# set of methods that provide access to the elements on the web pages.
+#
+module PageObject
+  module Accessors
+    #
+    # adds three methods to the page object - one to set text in a text field,
+    # another to retrieve text from a text field and another to return the text
+    # field element.
+    #
+    # Example:  text_field(:first_name, {:id => "first_name"})
+    # will generate the 'first_name', 'first_name=' and 'first_name_text_field methods.
+    #
+    # @param  the name used for the generated methods
+    # @param identifier how we find a text_field.  The valid values are:
+    #   :class => Watir and Selenium
+    #   :css => Watir and Selenium
+    #   :id => Watir and Selenium
+    #   :index => Watir only
+    #   :name => Watir and Selenium
+    #   :tag_name => Watir and Selenium
+    #   :text => Watir only
+    #   :value => Watir only
+    #   :xpath => Watir and Selenium
+    #
+    def text_field(name, identifier)
+      define_method(name) do
+        platform.text_field_value_for identifier
+      end
+      define_method("#{name}=") do |value|
+        platform.text_field_value_set(identifier, value)
+      end
+      define_method("#{name}_text_field") do
+        platform.text_field_for identifier
+      end
+    end
+
+    #
+    # adds three methods - one to select an item in a drop-down,
+    # another to fetch the currently selected item and another
+    # to retrieve the select list element.
+    #
+    # Example:  select_list(:state, {:id => "state"})
+    # will generate the 'state', 'state=' and 'state_select_list' methods
+    #
+    # @param the name used for the generated methods
+    # @param identifier how we find a select_list.  The valid values are:
+    #   :class => Watir and Selenium
+    #   :id => Watir and Selenium
+    #   :index => Watir only
+    #   :name => Watir and Selenium
+    #   :text => Watir only
+    #   :value => Watir only
+    #   :xpath => Watir and Selenium
+    #
+    def select_list(name, identifier)
+      define_method(name) do
+        platform.select_list_value_for identifier
+      end
+      define_method("#{name}=") do |value|
+        platform.select_list_value_set(identifier, value)
+      end
+      define_method("#{name}_select_list") do
+        platform.select_list_for identifier
+      end
+    end
+
+    #
+    # adds two methods - one to select a link and another
+    # to return a PageObject::Elements::Link object representing
+    # the link.
+    #
+    # Example:  link(:add_to_cart, {:text => "Add to Cart"})
+    # will generate the 'add_to_cart' and 'add_to_cart_link'
+    # method.
+    #
+    # @param the name used for the generated methods
+    # @param identifier how we find a link.  The valid values are:
+    #   :class => Watir and Selenium
+    #   :href => Watir only
+    #   :id => Watir and Selenium
+    #   :index => Watir only
+    #   :link => Watir and Selenium
+    #   :link_text => Watir and Selenium
+    #   :name => Watir and Selenium
+    #   :text => Watir and Selenium
+    #   :xpath => Watir and Selenium
+    #
+    def link(name, identifier)
+      define_method(name) do
+        platform.click_link_for identifier
+      end
+      define_method("#{name}_link") do
+        platform.link_for identifier
+      end
+    end
+    
+    #
+    # adds four methods - one to check, another to uncheck, another
+    # to return the state of a checkbox, and a final method to return
+    # a PageObject::Elements::CheckBox object representing the checkbox.
+    #
+    # Example: checkbox(:active, {:name => "is_active"})
+    # will generate the 'check_active', 'uncheck_active',
+    # 'active_checked?' and 'active_checkbox' methods.
+    #
+    # @param the name used for the generated methods
+    # @param identifier how we find a checkbox.  The valid values are:
+    #   :class => Watir and Selenium
+    #   :id => Watir and Selenium
+    #   :index => Watir only
+    #   :name => Watir and Selenium
+    #   :xpath => Watir and Selenium
+    #
+    def checkbox(name, identifier)
+      define_method("check_#{name}") do
+        platform.check_checkbox(identifier)
+      end
+      define_method("uncheck_#{name}") do
+        platform.uncheck_checkbox(identifier)
+      end
+      define_method("#{name}_checked?") do
+        platform.checkbox_checked?(identifier)
+      end
+      define_method("#{name}_checkbox") do
+        platform.checkbox_for identifier
+      end
+    end
+    
+    #
+    # adds four methods - one to select, another to clear,
+    # another to return if a radio button is selected, and
+    # another method to return a PageObject::Elements::RadioButton
+    # object representing the radio button element
+    #
+    # Example:  radio_button(:north, {:id => "north"})
+    # will generate 'select_north', 'clear_north',
+    # 'north_selected?' and 'north_radio_button' methods
+    #
+    # @param the name used for the generated methods
+    # @param identifier how we find a checkbox.  The valid values are:
+    #   :class => Watir and Selenium
+    #   :id => Watir and Selenium
+    #   :index => Watir only
+    #   :name => Watir and Selenium
+    #   :xpath => Watir and Selenium
+    #
+    def radio_button(name, identifier)
+      define_method("select_#{name}") do
+        platform.select_radio(identifier)
+      end
+      define_method("clear_#{name}") do
+        platform.clear_radio(identifier)
+      end
+      define_method("#{name}_selected?")  do
+        platform.radio_selected?(identifier)
+      end
+      define_method("#{name}_radio_button") do
+        platform.radio_button_for identifier
+      end
+    end
+
+    def button(name, identifier)
+      define_method(name) do
+      end
+    end
+  end
+end

data/lib/page-object/elements.rb

@@ -0,0 +1,8 @@
+
+require 'page-object/elements/element'
+require 'page-object/elements/link'
+require 'page-object/elements/text_field'
+require 'page-object/elements/select_list'
+require 'page-object/elements/check_box'
+require 'page-object/elements/button'
+require 'page-object/elements/radio_button'

data/lib/page-object/elements/button.rb

@@ -0,0 +1,15 @@
+module PageObject
+  module Elements
+    class Button < Element
+
+      def self.watir_identifier_for identifier
+        identifier_for identifier, watir_finders, watir_mapping
+      end
+
+      def self.selenium_identifier_for identifier
+        identifier_for identifier, selenium_finders, selenium_mapping
+        return identifier.keys.first, identifier.values.first
+      end
+    end
+  end
+end

data/lib/page-object/elements/check_box.rb

@@ -0,0 +1,15 @@
+module PageObject
+  module Elements
+    class CheckBox < Element
+
+      def self.watir_identifier_for identifier
+        identifier_for identifier, watir_finders, watir_mapping
+      end
+
+      def self.selenium_identifier_for identifier
+        identifier = identifier_for identifier, selenium_finders, selenium_mapping
+        return identifier.keys.first, identifier.values.first
+      end
+    end
+  end
+end

data/lib/page-object/elements/element.rb

@@ -0,0 +1,52 @@
+module PageObject
+  module Elements
+
+    #
+    # Contains functionality that is common across all elements.
+    #
+    class Element
+      
+      def initialize(element, platform)
+        @element = element
+        include_platform_for platform
+      end
+      
+      def self.identifier_for identifier, find_by, find_by_mapping
+        how, what = identifier.keys.first, identifier.values.first
+        return how => what if find_by.include? how
+        return find_by_mapping[how] => what if find_by_mapping[how]
+        return nil => what
+      end
+      
+      protected
+
+      def self.watir_finders
+        [:class, :id, :index, :name, :xpath]
+      end
+      
+      def self.watir_mapping
+        {}
+      end
+      
+      def self.selenium_finders
+        [:class, :id, :name, :xpath]
+      end
+      
+      def self.selenium_mapping
+        {}
+      end
+      
+      private
+      
+      def include_platform_for platform
+        if platform[:platform] == :watir
+          require 'page-object/watir_element'
+          self.class.send :include, PageObject::WatirElement
+        else
+          require 'page-object/selenium_element'
+          self.class.send :include, PageObject::SeleniumElement
+        end
+      end
+    end
+  end
+end