symbiont 0.1.8 → 0.1.9

data/lib/symbiont/generators.rb

@@ -16,9 +16,9 @@ module Symbiont
     def title_is(title)
       define_method('has_title?') do
         sleep 1
-        valid_title = title =~ browser.title if title.kind_of?(Regexp)
-        valid_title = title == browser.title if title.kind_of?(String)
-        raise "\n\nExpected title: '#{title}'; Actual title: '#{browser.title}'" unless valid_title
+        valid_title = title =~ @browser.title if title.kind_of?(Regexp)
+        valid_title = title == @browser.title if title.kind_of?(String)
+        raise "\n\nExpected title: '#{title}'; Actual title: '#{@browser.title}'" unless valid_title
         valid_title
       end
     end
@@ -137,70 +137,35 @@ module Symbiont
 
 
 
-    # Definition method for tables. Methods for the following actions will be created:
-    # * reference a table (identifier_object, identifier_table)
-    # * check for existence (identifier?, identifier_exists?)
-    # * check for visibility (identifier_?, identifier_visible?)
-    # @param [Symbol] identifier the friendly name of the web object
-    # @param [optional, Hash] locator the key/values that identify the object
-    # @return [Object] instance of Symbiont::WebObjects::Table
     def table(identifier, locator)
-      define_method("#{identifier}_object") do
-        @platform.get_table_for(locator.clone)
-      end
-      
-      alias_method "#{identifier}_table".to_sym, "#{identifier}_object".to_sym
-      
-      define_method("#{identifier}_exists?") do
-        @platform.check_table_for_existence(locator.clone)
-      end
-      
-      alias_method "#{identifier}?".to_sym, "#{identifier}_exists?".to_sym
-      
-      define_method("#{identifier}_visible?") do
-        @platform.check_table_for_visibility(locator.clone)
+      define_method(identifier) do
+        platform.table_text_for(locator.clone)
       end
-      
-      alias_method "#{identifier}_?".to_sym, "#{identifier}_visible?".to_sym
+
+      common_definition_methods(identifier, locator, 'table_element')
     end
     
-    # Definition method for table cells. Methods for the following actions will be created:
-    # * reference a table cell (identifier_object, identifier_cell)
-    # * check for existence (identifier?, identifier_exists?)
-    # * check for visibility (identifier_?, identifier_visible?)
-    # * get text from cell (identifier)
-    # @param [Symbol] identifier the friendly name of the web object
-    # @param [optional, Hash] locator the key/values that identify the object
-    # @return [Object] instance of Symbiont::WebObjects::TableCell
     def cell(identifier, locator)
-      define_method("#{identifier}_object") do
-        @platform.get_table_cell_for(locator.clone)
-      end
-      
-      alias_method "#{identifier}_cell".to_sym, "#{identifier}_object".to_sym
-      
-      define_method("#{identifier}_exists?") do
-        @platform.check_table_cell_for_existence(locator.clone)
-      end
-      
-      alias_method "#{identifier}?".to_sym, "#{identifier}_exists?".to_sym
-      
-      define_method("#{identifier}_visible?") do
-        @platform.check_table_cell_for_visibility(locator.clone)
-      end
-      
-      alias_method "#{identifier}_?".to_sym, "#{identifier}_visible?".to_sym
-      
-      define_method("#{identifier}") do
-        @platform.get_table_cell_text_for(locator.clone)
+      define_method(identifier) do
+        platform.get_table_cell_text_for(locator.clone)
       end
+
+      common_definition_methods(identifier, locator, 'cell_element')
     end
-    
+
     def div(identifier, locator)
+      define_method(identifier) do
+        platform.div_text_for(locator.clone)
+      end
+
       common_definition_methods(identifier, locator, 'div_element')
     end
     
     def span(identifier, locator)
+      define_method(identifier) do
+        platform.span_text_for(locator.clone)
+      end
+
       common_definition_methods(identifier, locator, 'span_element')
     end
 
@@ -225,7 +190,8 @@ module Symbiont
         platform.send(method, locator.clone).text
       end
 
-      element = method[0..method.index("_") - 1]
+      element = method[0..method.rindex("_") - 1] if method.count("_") == 2
+      element = method[0..method.index("_") - 1]  if method.count("_") == 1
 
       alias_method "#{identifier}_#{element}".to_sym, "#{identifier}_object".to_sym
       alias_method "#{identifier}?".to_sym, "#{identifier}_exists?".to_sym

data/lib/symbiont/locators.rb

@@ -1,43 +1,43 @@
 module Symbiont
   module Locators
     def link_object(locator)
-      @platform.get_link_for(locator)
+      platform.link_element(locator)
     end
     
     def button_object(locator)
-      @platform.get_button_for(locator)
+      platform.button_element(locator)
     end
     
     def text_field_object(locator)
-      @platform.get_text_field_for(locator)
+      platform.text_field_element(locator)
     end
     
     def select_list_object(locator)
-      @platform.get_select_list_for(locator)
+      platform.select_list_element(locator)
     end
     
     def checkbox_object(locator)
-      @platform.get_checkbox_for(locator)
+      platform.checkbox_element(locator)
     end
     
     def radio_object(locator)
-      @platform.get_radio_for(locator)
+      platform.radio_element(locator)
     end
     
     def div_object(locator)
-      @platform.get_div_for(locator)
+      platform.div_element(locator)
     end
     
     def span_object(locator)
-      @platform.get_span_for(locator)
+      platform.span_element(locator)
     end
     
     def table_object(locator)
-      @platform.get_table_for(locator)
+      platform.table_element(locator)
     end
     
     def cell_object(locator)
-      @platform.get_table_cell_for(locator)
+      platform.cell_element(locator)
     end
   end # module: Locators
 end # module: Symbiont

data/lib/symbiont/platform_watir/platform_object.rb

@@ -48,7 +48,7 @@ module Symbiont
           web_object = @browser.execute_script("return document.activeElement")
           type = web_object.type.to_sym if web_object.tag_name.to_sym == :input
           object_class = ::Symbiont::WebObjects.get_class_for(web_object.tag_name, type)
-          object_class.new(web_object, :platform => :watir_webdriver)
+          object_class.new(web_object)
         end
         
         ## Encloser Methods ##
@@ -100,11 +100,11 @@ module Symbiont
         ## Paragraphs ##
 
         def paragraph_element(locator)
-          reference_web_object("p(locator)", WebObjects::Paragraph, locator)
+          reference_web_object("p(locator)", WebObjects::Paragraph, locator, 'p')
         end
 
         def paragraph_text_for(locator)
-          access_web_object("p(locator).text", WebObjects::Paragraph, locator)
+          access_web_object("p(locator).text", WebObjects::Paragraph, locator, nil, 'p')
         end
 
         ## Links ##
@@ -191,61 +191,37 @@ module Symbiont
           access_web_object("radio(locator).set", WebObjects::Radio, locator)
         end
 
+        def table_element(locator)
+          reference_web_object("table(locator)", WebObjects::Table, locator, 'table')
+        end
 
-
-        
-        # Platform method to return a table object.
-        # Table objects are of type: Symbiont::WebObjects::Table
-        # @see Symbiont::Generators#table
-        def get_table_for(locator)
-          reference_web_object("table(locator)", WebObjects::Table, locator)
+        def table_text_for(locator)
+          access_web_object("table(locator).text", WebObjects::Table, locator, nil, 'table')
         end
-        
-        # Platform method to check if table object exists.
-        # @see Symbiont::Generators#table
-        #def check_table_for_existence(locator)
-        #  access_web_object("table(locator).exists?", WebObjects::Table, locator)
-        #end
-        
-        # Platform method to check if table object is visible.
-        # @see Symbiont::Generators#table
-        #def check_table_for_visibility(locator)
-        #  access_web_object("table(locator).visible?", WebObjects::Table, locator)
-        #end
-        
-        # Platform method to return a table cell object.
-        # Table cell objects are of type: Symbiont::WebObjects::TableCell
-        # @see Symbiont::Generators#cell
-        def get_table_cell_for(locator)
-          reference_web_object("td(locator)", WebObjects::TableCell, locator)
+
+
+        def cell_element(locator)
+          reference_web_object("td(locator)", WebObjects::TableCell, locator, 'td')
         end
         
-        # Platform method to check if table cell object exists.
-        # @see Symbiont::Generators#cell
-        #def check_table_cell_for_existence(locator)
-        #  access_web_object("td(locator).exists?", WebObjects::TableCell, locator)
-        #end
-        
-        # Platform method to check if table cell object is visible.
-        # @see Symbiont::Generators#cell
-        #def check_table_cell_for_visibility(locator)
-        #  access_web_object("td(locator).visible?", WebObjects::TableCell, locator)
-        #end
-        
-        # Platform method to get text of table cell object.
-        # @see Symbiont::Generators#cell
         def get_table_cell_text_for(locator)
-          access_web_object("td(locator).text", WebObjects::TableCell, locator)
+          access_web_object("td(locator).text", WebObjects::TableCell, locator, nil, 'td')
         end
-        
-
 
         def div_element(locator)
-          reference_web_object("div(locator)", WebObjects::Div, locator)
+          reference_web_object("div(locator)", WebObjects::Div, locator, 'div')
+        end
+
+        def div_text_for(locator)
+          access_web_object("div(locator).text", WebObjects::Div, locator, nil, 'div')
         end
 
         def span_element(locator)
-          reference_web_object("span(locator)", WebObjects::Span, locator)
+          reference_web_object("span(locator)", WebObjects::Span, locator, 'span')
+        end
+
+        def span_text_for(locator)
+          access_web_object("span(locator).text", WebObjects::Span, locator, nil, 'span')
         end
 
         private
@@ -257,12 +233,12 @@ module Symbiont
         # @param [Object] object_type the type of web object that will receive the action
         # @param [Hash] locator the specific web object selector, mainly for parsing
         # @return [Object] the web object identified by the action
-        def reference_web_object(action, object_type, locator)
+        def reference_web_object(action, object_type, locator, object_tag=nil)
           enclosers = locator.delete(:frame)
-          locator = object_type.provide_watir_locator_for(locator)
+          locator = object_type.provide_locator_for(locator)
           web_object = @browser.instance_eval "#{enclosed_by(enclosers)}#{action}"
           @browser.wd.switch_to.default_content unless enclosers.nil?
-          object_type.new(web_object, :platform => :watir_webdriver)
+          object_type.new(web_object)
         end
         
         # This method is called by any platform methods that require accessing
@@ -274,9 +250,9 @@ module Symbiont
         # @param [String] value any specific information that must be sent to the
         # web object
         # @return [Any] the information or object returned by the action
-        def access_web_object(action, object_type, locator, value=nil)
+        def access_web_object(action, object_type, locator, value=nil, object_tag=nil)
           enclosers = locator.delete(:frame)
-          locator = object_type.provide_watir_locator_for(locator)
+          locator = object_type.provide_locator_for(locator)
           object = @browser.instance_eval "#{enclosed_by(enclosers)}#{action}"
           @browser.wd.switch_to.default_content unless enclosers.nil?
           object

data/lib/symbiont/platform_watir.rb

@@ -2,17 +2,8 @@ module Symbiont
   module Platforms
     module WatirWebDriver
 
-      def self.create_platform_object_for(browser)
-        require_relative 'platform_watir/platform_object'
-        return WatirWebDriver::PlatformObject.new(browser)
-      end
-
-      def self.works_with(browser)
-        browser.is_a?(::Watir::Browser)
-      end
+      require_relative 'platform_watir/platform_object'
 
     end
   end
-end
-
-Symbiont::Platforms.register(:watir_webdriver, Symbiont::Platforms::WatirWebDriver)
+end

data/lib/symbiont/platforms.rb

@@ -2,34 +2,22 @@ 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, 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}"
+    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
     end
 
-  end # module: Platforms
-end # module: Symbiont
+  end
+end
 
 require_relative 'platform_watir'
-require_relative 'platform_selenium'

data/lib/symbiont/version.rb

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

data/lib/symbiont/web_objects/_common.rb

@@ -9,9 +9,8 @@ module Symbiont
     class WebObject
       attr_reader :web_object
 
-      def initialize(web_object, platform)
+      def initialize(web_object)
         @web_object = web_object
-        include_platform_specifics_for(platform)
       end
       
       def enabled?
@@ -22,15 +21,51 @@ module Symbiont
         not enabled?
       end
 
+      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 text
         web_object.text
       end
+
+      def html
+        web_object.html
+      end
       
       def click
         web_object.click
       end
 
-      def tag
+      def double_click
+        web_object.double_click
+      end
+
+      def tag_name
         web_object.tag_name
       end
 
@@ -46,50 +81,93 @@ module Symbiont
         web_object.inspect
       end
 
-      def self.usable_selectors_for_watir
-        [:id, :name, :xpath, :class, :index]
+      def hover
+        web_object.hover
       end
 
-      def self.usable_selectors_for_selenium
-        [:id, :name, :xpath, :class, :index, :css]
+      def fire_event(event)
+        web_object.fire_event(event)
       end
 
-      def self.selector_mapping_for_watir
-        {}
+      def send_keys(*args)
+        web_object.send_keys(*args)
       end
 
-      def self.selector_mapping_for_selenium
-        {}
+      def ==(other)
+        web_object == other.web_object
       end
-      
-      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}
+
+      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)
+      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)
+        self
+      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
 
-      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
+      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
 
-      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
+      def self.usable_selectors
+        [:id, :name, :xpath, :class, :index]
       end
 
-      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."
+      def self.selector_mapping
+        {}
+      end
+
+      #def self.locator_for(locator)
+      #  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
+      #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
         end
       end
+
     end # class: WebObject
 
   end # module: WebObjects

data/lib/symbiont/web_objects/button.rb

@@ -3,27 +3,14 @@ module Symbiont
 
     class Button < WebObject
 
-      def initialize(web_object, platform)
+      def initialize(web_object)
         @web_object = web_object
-        include_platform_specifics_for(platform)
       end
 
-      def self.usable_selectors_for_watir
+      def self.usable_selectors
         super + [:value, :text, :src, :alt, :css]
       end
 
-      def self.usable_selectors_for_selenium
-        super + [:value, :src, :alt]
-      end
-
-      def include_platform_specifics_for(platform)
-        super
-        if platform[:platform] == :selenium_webdriver
-          require 'symbiont/platform_selenium/web_objects/button'
-          self.class.send :include, Symbiont::Platforms::SeleniumWebDriver::Button
-        end
-      end
-
     end # class: Button
     
     ::Symbiont::WebObjects.class_for_type[:submit] = ::Symbiont::WebObjects::Button

data/lib/symbiont/web_objects/checkbox.rb

@@ -3,30 +3,24 @@ module Symbiont
 
     class CheckBox < WebObject
 
-      def initialize(web_object, platform)
+      def initialize(web_object)
         @web_object = web_object
-        include_platform_specifics_for(platform)
       end
 
-      def self.usable_selectors_for_watir
-        super + [:value]
+      def check
+        web_object.set
       end
 
-      def self.usable_selectors_for_selenium
-        super + [:value]
+      def uncheck
+        web_object.clear
       end
 
-      def include_platform_specifics_for(platform)
-        super
-        if platform[:platform] == :watir_webdriver
-          require 'symbiont/platform_watir/web_objects/checkbox'
-          self.class.send :include, Symbiont::Platforms::WatirWebDriver::CheckBox
-        elsif platform[:platform] == :selenium_webdriver
-          require 'symbiont/platform_selenium/web_objects/checkbox'
-          self.class.send :include, Symbiont::Platforms::SeleniumWebDriver::CheckBox
-        else
-          raise ArgumentError, "The platform #{platform[:platform]} appears to be unsupported."
-        end
+      def checked?
+        web_object.set?
+      end
+
+      def self.usable_selectors
+        super + [:value]
       end
 
     end # class: CheckBox

data/lib/symbiont/web_objects/div.rb

@@ -3,11 +3,7 @@ module Symbiont
     
     class Div < WebObject
 
-      def self.usable_selectors_for_watir
-        super + [:text, :title]
-      end
-
-      def self.usable_selectors_for_selenium
+      def self.usable_selectors
         super + [:text, :title]
       end
 

data/lib/symbiont/web_objects/link.rb

@@ -3,35 +3,18 @@ module Symbiont
 
     class Link < WebObject
 
-      def initialize(web_object, platform)
+      def initialize(web_object)
         @web_object = web_object
-        include_platform_specifics_for(platform)
       end
 
-      def self.usable_selectors_for_watir
+      def self.usable_selectors
         super + [:href, :text, :title, :css]
       end
       
-      def self.selector_mapping_for_watir
+      def self.selector_mapping
         super.merge({:link => :text, :link_text => :text})
       end
 
-      def self.usable_selectors_for_selenium
-        super + [:link, :link_text, :title]
-      end
-
-      def self.selector_mapping_for_selenium
-        super.merge(:text => :link_text)
-      end
-
-      def include_platform_specifics_for(platform)
-        super
-        if platform[:platform] == :selenium_webdriver
-          require 'symbiont/platform_selenium/web_objects/link'
-          self.class.send :include, Symbiont::Platforms::SeleniumWebDriver::Link
-        end
-      end
-
     end # class: Link
     
     ::Symbiont::WebObjects.class_for_tag[:a] = ::Symbiont::WebObjects::Link