page-object-lds 0.0.1

data/lib/page-object/platforms/watir_webdriver/radio_button.rb

@@ -0,0 +1,22 @@
+module PageObject
+  module Platforms
+    module WatirWebDriver
+      module RadioButton
+
+        #
+        # select the radiobutton
+        #
+        def select
+          element.set
+        end
+
+        #
+        # return if it is selected
+        #
+        def selected?
+          element.set?
+        end
+      end
+    end
+  end
+end

data/lib/page-object/platforms/watir_webdriver/select_list.rb

@@ -0,0 +1,74 @@
+module PageObject
+  module Platforms
+    module WatirWebDriver
+      module SelectList
+
+        #
+        # Return the PageObject::Elements::Option for the index provided.  Index
+        # is zero based.
+        #
+        # @return [PageObject::Elements::Option]
+        #
+        def [](idx)
+          options[idx]
+        end
+
+        #
+        # Select a value from the list
+        #
+        def select(value)
+          element.select(value)
+        end
+
+        #
+        # Select the option(s) whose value attribute matches the given
+        # string
+        #
+        def select_value(value)
+          element.select_value(value)
+        end
+
+        #
+        # Return an array of Options contained in the select list.
+        #
+        # @return [array of PageObject::Elements::Option]
+        #
+        def options
+          element.options.map { |e| ::PageObject::Elements::Option.new(e, :platform => :watir_webdriver) }
+        end
+
+        #
+        # @return [Array<String>] An array of strings representing the text of the currently selected options.
+        #
+        def selected_options
+          element.selected_options.map { |e| e.text }.compact
+        end
+
+        #
+        # @return [Array<String>] An array of strings representing the value of the currently selected options.
+        #
+        def selected_values
+          element.selected_options.map { |e| e.value }.compact
+        end
+
+        #
+        # Returns true if the select list has one or more options where text or label matches the given value.
+        #
+        # @param [String, Regexp] value A value.
+        # @return [Boolean]
+        def include?(value)
+          element.include? value
+        end
+        
+        #
+        # Returns true if any of the selected options' text or label match the given value.
+        #
+        # @param [String, Regexp] value A value.
+        # @return [Boolean]
+        def selected?(value)
+          element.selected? value
+        end
+      end
+    end
+  end
+end

data/lib/page-object/platforms/watir_webdriver/table.rb

@@ -0,0 +1,38 @@
+module PageObject
+  module Platforms
+    module WatirWebDriver
+
+      module Table
+
+        #
+        # Return the PageObject::Elements::TableRow for the index provided.  Index
+        # is zero based.  If the index provided is a String then it
+        # will be matched with the text from any column. The text can be a substring of the full column text.
+        #
+        # @return [PageObject::Elements::TableRow]
+        #
+        def [](idx)
+          idx = find_index_by_title(idx) if idx.kind_of?(String)
+          return nil unless idx
+          initialize_row(element[idx], :platform => :watir_webdriver)
+        end
+
+        #
+        # Returns the number of rows in the table.
+        #
+        def rows
+          element.wd.find_elements(:xpath, child_xpath).size
+        end
+
+        private
+
+        def find_index_by_title(row_title)
+          element.rows.find_index do |row|
+            row.cells.any? { |col| col.text.include? row_title }
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/page-object/platforms/watir_webdriver/table_row.rb

@@ -0,0 +1,37 @@
+module PageObject
+  module Platforms
+    module WatirWebDriver
+      module TableRow
+
+        #
+        # Return the PageObject::Elements::TableCell for the index provided.  Index
+        # is zero based.  If the index provided is a String then it
+        # will be matched with the text from the columns in the first row.
+        # The text can be a substring of the full column text.
+        #
+        def [](idx)
+          idx = find_index_by_title(idx) if idx.kind_of?(String)
+          return nil unless idx && columns >= idx + 1
+          initialize_cell(element[idx], :platform => :watir_webdriver)
+        end
+
+        #
+        # Returns the number of columns in the table.
+        #
+        def columns
+          element.wd.find_elements(:xpath, child_xpath).size
+        end
+
+        private
+
+        def find_index_by_title(title)
+          table = element.parent
+          table = table.parent if table.tag_name == 'tbody'
+          first_row = table[0]
+          first_row.cells.find_index {|column| column.text.include? title }
+        end
+
+      end
+    end
+  end
+end

data/lib/page-object/platforms/watir_webdriver/text_area.rb

@@ -0,0 +1,23 @@
+module PageObject
+  module Platforms
+    module WatirWebDriver
+
+      module TextArea
+        
+        #
+        # Set the value of the TextArea
+        #
+        def value=(new_value)
+          element.set(new_value)
+        end
+        
+        #
+        # Clear the TextArea
+        #
+        def clear
+          element.wd.clear
+        end
+      end
+    end
+  end
+end

data/lib/page-object/platforms/watir_webdriver/text_field.rb

@@ -0,0 +1,16 @@
+module PageObject
+  module Platforms
+    module WatirWebDriver
+
+      module TextField
+        
+        #
+        # Set the value of the TextField
+        #
+        def value=(new_value)
+          element.set(new_value)
+        end
+      end
+    end
+  end
+end

data/lib/page-object/platforms/watir_webdriver/unordered_list.rb

@@ -0,0 +1,36 @@
+module PageObject
+  module Platforms
+    module WatirWebDriver
+      module UnorderedList
+
+        #
+        # Return the PageObject::Elements::ListItem for the index provided.  Index
+        # is zero based.
+        #
+        # @return [PageObject::Elements::ListItem]
+        #
+        def [](idx)
+          Object::PageObject::Elements::ListItem.new(children[idx], :platform => :watir_webdriver)
+        end
+
+        #
+        # Return the number of items contained in the unordered list
+        #
+        def items
+          children.size
+        end
+
+        private
+
+        def children
+          list_items.find_all { |item| item.parent == element }
+        end
+        
+        def list_items
+          element.uls(:xpath => child_xpath)
+        end
+
+      end
+    end
+  end
+end

data/lib/page-object/version.rb

@@ -0,0 +1,4 @@
+module PageObject
+  # @private
+  VERSION = "0.0.1"
+end

data/lib/page-object/widgets.rb

@@ -0,0 +1,134 @@
+require 'page-object/elements'
+require 'page-object/platforms/selenium_webdriver/page_object'
+require 'page-object/platforms/watir_webdriver/page_object'
+require 'page-object/platforms/lds_watir_webdriver/page_object'
+
+module PageObject
+  module Widgets
+
+    #
+    # Module that allows for the registration of widget classes which extend the functionality of PageObject
+    # Allows any classes which extend PageObject::Element to be used as PageObject elements.
+    # This allows such widgets to be created using the defined tags.
+    #
+    # @param [Symbol] defines the symbol which will be used as an accessor name.
+    # @param [Class] the widget class extending PageObject::Elements::Element
+    # @param [Symbol] the symbol of the html element used when searching for this widget.
+    #
+    #
+    def self.register_widget(widget_tag, widget_class, base_element_tag)
+      if widget_class.ancestors.include? Elements::Element
+        define_accessors(Accessors, widget_tag, widget_class)
+        define_nested_elements(Elements::Element, widget_tag)
+        define_locators(PageObject, widget_tag)
+        define_selenium_accessors(Platforms::SeleniumWebDriver::PageObject, widget_tag, widget_class, base_element_tag)
+        define_watir_accessors(Platforms::WatirWebDriver::PageObject, widget_tag, widget_class, base_element_tag)
+      end
+    end
+
+    private
+
+    def self.define_accessors(base, widget_tag, widget_class)
+      accessors_module = Module.new do
+        define_method widget_tag do |name, *identifier_args, &block|
+          
+          identifier = identifier_args.first
+          identifier = {:index => 0} if identifier.nil?
+          
+          define_method("#{name}_element") do
+            return call_block(&block) if block
+            platform.send("#{widget_tag}_for", identifier.clone)
+          end
+          define_method("#{name}?") do
+            return call_block(&block).exists? if block
+            platform.send("#{widget_tag}_for", identifier.clone).exists?
+          end
+          if widget_class.respond_to? :accessor_methods
+            widget_class.accessor_methods(self, name)
+          end
+        end
+        define_method widget_class.plural_form do |name, *identifier_args, &block|
+          define_method("#{name}_elements") do
+            return call_block(&block) unless block.nil?
+            platform_method = "#{widget_tag.to_s}s_for"
+            platform.send platform_method, (identifier_args.first ? identifier_args.first.clone : {})
+          end
+        end
+      end
+
+      base.send(:include, accessors_module)
+    end
+
+    def self.define_watir_accessors(base, widget_tag, widget_class, base_element_tag)
+      define_singular_watir_accessor(base, base_element_tag, widget_class, widget_tag)
+      define_multiple_watir_accessor(base, base_element_tag, widget_class, widget_tag)
+    end
+
+    def self.define_multiple_watir_accessor(base, base_element_tag, widget_class, widget_tag)
+      base.send(:define_method, "#{widget_tag}s_for") do |identifier|
+        find_watir_elements("#{base_element_tag}s(identifier)", widget_class, identifier, base_element_tag)
+      end
+    end
+
+    def self.define_singular_watir_accessor(base, base_element_tag, widget_class, widget_tag)
+      base.send(:define_method, "#{widget_tag}_for") do |identifier|
+        find_watir_element("#{base_element_tag}(identifier)", widget_class, identifier, base_element_tag)
+      end
+    end
+
+    def self.define_selenium_accessors(base, widget_tag, widget_class, base_element_tag)
+      define_singular_selenium_accessor(base, base_element_tag, widget_class, widget_tag)
+      define_multiple_selenium_accessor(base, base_element_tag, widget_class, widget_tag)
+    end
+
+    def self.define_multiple_selenium_accessor(base, base_element_tag, widget_class, widget_tag)
+      base.send(:define_method, "#{widget_tag}s_for") do |identifier|
+        find_selenium_elements(identifier, widget_class, base_element_tag)
+      end
+    end
+
+    def self.define_singular_selenium_accessor(base, base_element_tag, widget_class, widget_tag)
+      base.send(:define_method, "#{widget_tag}_for") do |identifier|
+        find_selenium_element(identifier, widget_class, base_element_tag)
+      end
+    end
+
+    def self.define_nested_elements(base, widget_tag)
+      define_singular_nested_accessor(base, widget_tag)
+      define_multiple_nested_accessor(base, widget_tag)
+    end
+
+    def self.define_multiple_nested_accessor(base, widget_tag)
+      base.send(:define_method, "#{widget_tag}_elements") do |*args|
+        identifier = args[0] ? args[0] : {:index => 0}
+        @platform.send("#{widget_tag}s_for", identifier.clone)
+      end
+    end
+
+    def self.define_singular_nested_accessor(base, widget_tag)
+      base.send(:define_method, "#{widget_tag}_element") do |*args|
+        identifier = args[0] ? args[0] : {:index => 0}
+        @platform.send("#{widget_tag}_for", identifier.clone)
+      end
+    end
+
+    def self.define_locators(base, widget_tag)
+      define_singular_locator(base, widget_tag)
+      define_multiple_locator(base, widget_tag)
+    end
+
+    def self.define_multiple_locator(base, widget_tag)
+      base.send(:define_method, "#{widget_tag}_elements") do |*args|
+        identifier = args[0] ? args[0] : {}
+        platform.send("#{widget_tag}s_for", identifier.clone)
+      end
+    end
+
+    def self.define_singular_locator(base, widget_tag)
+      base.send(:define_method, "#{widget_tag}_element") do |*args|
+        identifier = args[0] ? args[0] : {:index => 0}
+        platform.send("#{widget_tag}_for", identifier.clone)
+      end
+    end
+  end
+end

data/page-object-lds.gemspec

@@ -0,0 +1,33 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "page-object/version"
+
+Gem::Specification.new do |s|
+  s.name = "page-object-lds"
+  s.version = PageObject::VERSION
+  s.platform = Gem::Platform::RUBY
+  s.authors = ["Mehdi Taoufik Chaouachi"]
+  s.date        = '2015-03-23'
+  s.email = ["mehditch@gmail.com"]
+  s.license       = 'MIT'
+  s.homepage = "https://github.com/mehdic/page-object-lds"
+  s.summary = %q{Page Object DSL for browser testing}
+  s.description = %q{Page Object DSL that works with both Watir , Selenium and FWK360 LDS platform}
+
+  s.rubyforge_project = "page-object-lds"
+
+  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.6.11'
+  s.add_dependency 'selenium-webdriver', '>= 2.44.0'
+  s.add_dependency 'page_navigation', '>= 0.9'
+
+  s.add_development_dependency 'rspec', '~> 3.1.0'
+  s.add_development_dependency 'cucumber', '>= 1.3.0'
+  s.add_development_dependency 'yard', '>= 0.7.2'
+  s.add_development_dependency 'rack', '>= 1.0'
+
+end

data/pageobject.gems

@@ -0,0 +1 @@
+bundler

data/spec/page-object/accessors_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+class GenericPage
+  include PageObject
+
+  wait_for_expected_title 'expected title'
+end
+
+describe  'accessors' do
+  let(:browser) { mock_watir_browser }
+  let(:page) { GenericPage.new browser }
+
+  context '#wait_for_expected_title' do
+    before(:each) do
+      allow(browser).to receive(:wait_until).and_yield
+    end
+
+    it 'true if already there' do
+      allow(browser).to receive(:title).and_return 'expected title'
+      expect(page.wait_for_expected_title?).to be_truthy
+    end
+
+    it 'does not wait if it already is there' do
+      allow(browser).to receive(:title).and_return 'expected title'
+      expect(browser).to_not receive(:wait_until)
+
+      expect(page.wait_for_expected_title?).to be_truthy
+    end
+
+    it 'errors when it does not match' do
+      allow(browser).to receive(:title).and_return 'wrong title'
+      expect { page.wait_for_expected_title? }.to raise_error "Expected title 'expected title' instead of 'wrong title'"
+    end
+
+    it 'picks up when the title changes' do
+      allow(browser).to receive(:title).and_return 'wrong title', 'expected title'
+      expect(page.wait_for_expected_title?).to be_truthy
+    end
+  end
+end