symbiont 0.1.7 → 0.1.8

data/lib/symbiont/platform_watir/web_objects/checkbox.rb

@@ -0,0 +1,21 @@
+module Symbiont
+  module Platforms
+    module WatirWebDriver
+      module CheckBox
+
+        def check
+          web_object.set
+        end
+
+        def uncheck
+          web_object.clear
+        end
+
+        def checked?
+          web_object.set?
+        end
+
+      end
+    end
+  end
+end

data/lib/symbiont/platform_watir/web_objects/common.rb

@@ -0,0 +1,82 @@
+module Symbiont
+  module Platforms
+    module WatirWebDriver
+      module WebObject
+
+        def visible?
+          web_object.present?
+        end
+
+        def exists?
+          web_object.exists?
+        end
+
+        def id
+          web_object.id
+        end
+
+        def value
+          web_object.value
+        end
+
+        def flash
+          web_object.flash
+        end
+
+        def attribute(name)
+          web_object.attribute_value(name)
+        end
+
+        def focus
+          web_object.focus
+        end
+
+        def parent
+          parent = web_object.parent
+          type = web_object.type if parent.tag_name.to_sym == :input
+          object_class = ::Symbiont::WebObjects.get_class_for(parent.tag_name, type)
+          object_class.new(parent, :platform => :watir_webdriver)
+        end
+
+        def wait_until(timeout=::Symbiont.element_level_wait, message=nil, &block)
+          Object::Watir::Wait.until(timeout, message, &block)
+        end
+
+        def when_actionable(timeout=::Symbiont.element_level_wait)
+          web_object.wait_until_present(timeout)
+          self
+        end
+
+        alias_method :when_present, :when_actionable
+
+        def when_not_actionable(timeout=::Symbiont.element_level_wait)
+          web_object.wait_while_present(timeout)
+        end
+
+        alias_method :when_not_present, :when_not_actionable
+
+        def when_visible(timeout=::Symbiont.element_level_wait)
+          Object::Watir::Wait.until(timeout, "Object not visible within #{timeout} seconds.") do
+            visible?
+          end
+          self
+        end
+
+        def when_not_visible(timeout=::Symbiont.element_level_wait)
+          Object::Watir::Wait.while(timeout, "Object still visible after #{timeout} seconds.") do
+            visible?
+          end
+          self
+        end
+
+        alias_method :must_be_visible, :when_visible
+        alias_method :must_not_be_visible, :when_not_visible
+
+        def scroll_into_view(wait=2)
+          sleep wait
+          web_object.wd.location_once_scrolled_into_view
+        end
+      end
+    end
+  end
+end

data/lib/symbiont/platform_watir/web_objects/radio.rb

@@ -0,0 +1,21 @@
+module Symbiont
+  module Platforms
+    module WatirWebDriver
+      module Radio
+
+        def select
+          web_object.set
+        end
+
+        def clear
+          web_object.clear
+        end
+
+        def selected?
+          web_object.set?
+        end
+
+      end
+    end
+  end
+end

data/lib/symbiont/platform_watir/web_objects/select_list.rb

@@ -0,0 +1,67 @@
+module Symbiont
+  module Platforms
+    module WatirWebDriver
+      module SelectList
+
+        # This method is used to return an Option object based on the index provided.
+        # @return [Symbiont::WebObjects::Option]
+        def [](idx)
+          ::Symbiont::WebObjects::Option.new(options[idx], :platform => :watir_webdriver)
+        end
+
+        # Selects an option from the select list.
+        def select(value)
+          web_object.select(value)
+        end
+
+        # Selects the option whose value attribute matches the provided string.
+        def select_value(value)
+          web_object.select_value(value)
+        end
+
+        # This method returns an array of Option objects that are contained within
+        # a select list object.
+        # @return [array of Symbiont::WebObjects::Option]
+        def options
+          web_objects = []
+          options = web_object.wd.find_elements(:xpath, option_xpath)
+          options.each do |opt|
+            web_objects << ::Symbiont::WebObjects::Option.new(opt, :platform => :watir_webdriver)
+          end
+          web_objects
+        end
+
+        # This method returns an array of strings that contain the text of the
+        # currently selected options in a select list.
+        # @return [Array<String>]
+        def selected_options
+          web_object.selected_options.map { |e| e.text }.compact
+        end
+
+        # This method returns an array of strings that contain the values of the
+        # currently selected options in a select list.
+        # @return [Array<String>]
+        def selected_values
+          web_object.selected_options.map { |e| e.value }.compact
+        end
+
+        # This method returns true if any of the text or the lable of any option
+        # that is selected matches the provided value.
+        # @param [String, Regexp] value A value to check for
+        # @return [Boolean]
+        def selected?(value)
+          web_object.selected? value
+        end
+
+        # This method checks to see if the select list has one or more options
+        # where the text or the label matches the provided value.
+        # @param [String, Regexp] value A value to check for.
+        # @return [Boolean]
+        def include?(value)
+          web_object.include? value
+        end
+
+      end
+    end
+  end
+end

data/lib/symbiont/platform_watir/web_objects/table.rb

@@ -0,0 +1,31 @@
+module Symbiont
+  module Platforms
+    module WatirWebDriver
+      module Table
+
+        # This method is used to return a TableRow object based on the index provided. When
+        # the index provided is a string, the text will be matched with the text from the first
+        # column.
+        # @return [Symbiont::WebObjects::TableRow]
+        def [](index)
+          index = find_by_title(index) if index.kind_of?(String)
+          return nil unless index
+          ::Symbiont::WebObjects::TableRow.new(@web_object[index], :platform => :watir_webdriver)
+        end
+
+        # This method will return the number of rows in a table.
+        def rows
+          web_object.wd.find_elements(:xpath, row_xpath).size
+        end
+
+        def find_by_title(row_text)
+          #web_object.rows.find_index {|row| row[0].text == row_text}
+          web_object.rows.find_index do |row|
+            row.cells.any? { |col| col.text.include? row_text }
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/symbiont/platform_watir/web_objects/table_row.rb

@@ -0,0 +1,31 @@
+module Symbiont
+  module Platforms
+    module WatirWebDriver
+      module TableRow
+
+        # This method is used to return a TableCell object based on the index provided. When
+        # the index provided is a string, the text will be matched with the text from the
+        # columns in the first row.
+        # @return [Symbiont::WebObjects::TableCell]
+        def [](index)
+          index = find_by_title(index) if index.kind_of?(String)
+          return nil unless index && columns >= idx + 1
+          ::Symbiont::WebObjects::TableCell.new(web_object[index], :platform => :watir_webdriver)
+        end
+
+        # This method returns the number of columns in a table object.
+        def columns
+          web_object.wd.find_elements(:xpath, cell_xpath).size
+        end
+
+        def find_by_title(column_text)
+          table = web_object.parent
+          table = table.parent if table.tag_name == 'tbody'
+          first_row = table[0]
+          first_row.cells.find_index {|column| column.text.include? column_text}
+        end
+
+      end
+    end
+  end
+end

data/lib/symbiont/platform_watir/web_objects/text_field.rb

@@ -0,0 +1,13 @@
+module Symbiont
+  module Platforms
+    module WatirWebDriver
+      module TextField
+
+        def value=(value)
+          web_object.set value
+        end
+
+      end
+    end
+  end
+end

data/lib/symbiont/platforms.rb

@@ -2,22 +2,34 @@ module Symbiont
   module Platforms
 
     require 'watir-webdriver'
+    require 'selenium-webdriver'
+
+    @@drivers = {}
+
+    def self.list
+      @@drivers
+    end
+
+    def self.register(driver, platform_object)
+      @@drivers[driver] = platform_object
+    end
 
     # This module determines what execution platform Symbiont will use.
     # The decision is based on the browser that has been established for
     # the execution profile.
     #
     # @param [Object] browser the browser to establish the platform for
+    # @param [Hash] drivers the list of registered browser drivers
     # @returns [Object] a platform object to execute tests against
-    def get_platform_for(browser)
-      if browser.is_a?(Watir::Browser)
-        return @platform = Symbiont::Platforms::WatirWebDriver::PlatformObject.new(@browser)
-      else
-        raise "Unable to create a platform object for #{browser}"
-      end
+    def get_platform_for(browser, drivers)
+      drivers.each_value { |driver|
+        return driver.create_platform_object_for(browser) if driver.works_with(browser)
+      }
+      raise "Unable to create a platform object for #{browser}"
     end
 
   end # module: Platforms
 end # module: Symbiont
 
 require_relative 'platform_watir'
+require_relative 'platform_selenium'

data/lib/symbiont/version.rb

@@ -1,3 +1,3 @@
 module Symbiont
-  VERSION = "0.1.7"
+  VERSION = "0.1.8"
 end

data/lib/symbiont/web_objects/_common.rb

@@ -7,108 +7,87 @@ module Symbiont
     # platform).
     
     class WebObject
-      def initialize(web_object)
+      attr_reader :web_object
+
+      def initialize(web_object, platform)
         @web_object = web_object
+        include_platform_specifics_for(platform)
       end
       
       def enabled?
-        @web_object.enabled?
+        web_object.enabled?
       end
       
       def disabled?
         not enabled?
       end
-      
-      def exists?
-        @web_object.exists?
-      end
-      
-      def visible?
-        @web_object.present?
-      end
-      
+
       def text
-        @web_object.text
+        web_object.text
       end
       
       def click
-        @web_object.click
-      end
-      
-      def clear
-        @web_object.clear
-      end
-      
-      def attribute(name)
-        @web_object.attribute_value(name)
+        web_object.click
       end
-      
-      def style(property)
-        @web_object.style(property)
-      end
-      
+
       def tag
-        @web_object.tag_name
+        web_object.tag_name
       end
-      
-      def id
-        @web_object.id
+
+      def clear
+        web_object.clear
       end
-      
-      def value
-        @web_object.value
+
+      def style(property)
+        web_object.style(property)
       end
-      
+
       def inspect
-        @web_object.inspect
+        web_object.inspect
       end
-      
-      def flash
-        @web_object.flash
+
+      def self.usable_selectors_for_watir
+        [:id, :name, :xpath, :class, :index]
       end
-      
-      def when_actionable(timeout=5)
-        @web_object.wait_until_present(timeout)
-        self
+
+      def self.usable_selectors_for_selenium
+        [:id, :name, :xpath, :class, :index, :css]
       end
-      
-      alias :when_present :when_actionable
-      
-      def when_visible(timeout=5)
-        Object::Watir::Wait.until(timeout, "object not visible within #{timeout} seconds.") do
-          visible?
-        end
-        self
+
+      def self.selector_mapping_for_watir
+        {}
       end
-      
-      def when_not_visible(timeout=5)
-        Object::Watir::Wait.while(timeout, "object still visible after #{timeout} seconds.") do
-          visible?
-        end
-        self
+
+      def self.selector_mapping_for_selenium
+        {}
       end
       
-      alias :must_be_visible :when_visible
-      alias :must_not_be_visible :when_not_visible
-      
-      def wait_until(timeout, message=nil, &block)
-        Object::Watir::Wait.until(timeout, message, &block)
+      def self.provide_watir_locator_for(locator)
+        locator = locator_for(locator, usable_selectors_for_watir, selector_mapping_for_watir)
+        return {locator.keys.first => locator.values.first}
       end
-      
-      def self.usable_selectors
-        [:id, :name, :xpath, :class, :index]
+
+      def self.provide_selenium_locator_for(locator)
+        locator = locator_for(locator, usable_selectors_for_selenium, selector_mapping_for_selenium)
+        return locator.keys.first, locator.values.first
       end
-      
-      def self.selector_mapping
-        {}
+
+      def self.locator_for(locator, selectors, mappings)
+        how, what = locator.keys.first, locator.values.first
+        return how => what if selectors.include? how
+        return mappings[how] => what if mappings[how]
+        return nil => what
       end
-      
-      def self.provide_locator_for(locator)
-        locator.each do |key, value|
-          how, what = locator.keys.first, locator.values.first
-          return how => what if usable_selectors.include? how
-          return selector_mapping[how] => what if selector_mapping[how]
-          return nil => what
+
+      def include_platform_specifics_for(platform)
+        if platform[:platform] == :watir_webdriver
+          require 'symbiont/platform_watir/web_objects/common'
+          self.class.send :include, ::Symbiont::Platforms::WatirWebDriver::WebObject
+        elsif platform[:platform] == :selenium_webdriver
+          require 'symbiont/platform_selenium/web_objects/common'
+          self.class.send :include, ::Symbiont::Platforms::SeleniumWebDriver::WebObject
+        else
+          raise ArgumentError, "The platform #{platform[:platform]} appears to be unsupported."
         end
       end
     end # class: WebObject