symbiont 0.0.4 → 0.1.0

data/HISTORY.md

@@ -1,6 +1,12 @@
 Change Log and History
 ======================
 
+Version 0.1.0 / 2012-05-16
+--------------------------
+
+This release marks the start of alpha testing for the Symbiont library. Symbiont is now able to work with many primary web objects. This release also contains a full set of acceptance tests for current Symbiont functionality (see specs directory) as well as a full set of unit tests (see spec directory). Symbiont versions will only be released if there is one hundred percent unit coverage and an acceptance test for each added or modified feature.
+
+
 Version 0.0.4 / 2012-04-14
 --------------------------
 

data/cucumber.yml

@@ -1,4 +1,4 @@
 <% browser = "BROWSER=firefox" %>
-<% std_opts = "--color --format pretty --no-source" %>
+<% std_opts = "--tags ~@wip --color --format pretty --no-source" %>
 
 default: <%= browser %> <%= std_opts %> -r specs specs

data/lib/symbiont/generators.rb

@@ -1,4 +1,10 @@
 module Symbiont
+
+  # The Generators module is used to provide groupings of methods that are
+  # generated dynamically based on object declarations in page definitions.
+  # The method provided allow for referencing and accessing web objects.
+  # The platform object acts as a delegate for all method calls.
+  
   module Generators
 
     # This method allows for a url_is() method in definitions that will
@@ -168,11 +174,11 @@ module Symbiont
       define_method(identifier) do
         @platform.get_text_field_value_for(locator.clone)
       end
-
+      
       define_method("#{identifier}=") do |value|
         @platform.set_text_field_value_for(locator.clone, value)
       end
-
+      
       define_method("#{identifier}_exists?") do
         @platform.check_text_field_for_existence(locator.clone)
       end
@@ -191,6 +197,276 @@ module Symbiont
       
       alias_method "#{identifier}!".to_sym, "#{identifier}_enabled?".to_sym
     end
-
+    
+    # Definition method for select lists. Methods for the following actions
+    # will be created:
+    # * reference a checkbox (identifier_object, identifier_select_list)
+    # * check for existence (identifier?, identifier_exists?)
+    # * check for visibility (identifier_?, identifier_visible?)
+    # * check for enabled (identifier!, identifier_enabled?)
+    # * check for option (identifier_option?)
+    # * set selected value (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::SelectList
+    def select_list(identifier, locator)
+      define_method("#{identifier}_object") do
+        @platform.get_select_list_for(locator.clone)
+      end
+      
+      alias_method "#{identifier}_select_list".to_sym, "#{identifier}_object".to_sym
+      
+      define_method(identifier) do
+        @platform.get_select_list_item_for(locator.clone)
+      end
+      
+      define_method("#{identifier}_option?") do
+        @platform.get_select_list_value_for(locator.clone)
+      end
+      
+      define_method("#{identifier}=") do |value|
+        @platform.set_select_list_value_for(locator.clone, value)
+      end
+      
+      define_method("#{identifier}_exists?") do
+        @platform.check_select_list_for_existence(locator.clone)
+      end
+      
+      alias_method "#{identifier}?".to_sym, "#{identifier}_exists?".to_sym
+      
+      define_method("#{identifier}_visible?") do
+        @platform.check_select_list_for_visibility(locator.clone)
+      end
+      
+      alias_method "#{identifier}_?".to_sym, "#{identifier}_visible?".to_sym
+      
+      define_method("#{identifier}_enabled?") do
+        @platform.check_select_list_for_enabled(locator.clone)
+      end
+      
+      alias_method "#{identifier}!".to_sym, "#{identifier}_enabled?".to_sym
+    end
+    
+    # Definition method for checkboxes. Methods for the following actions
+    # will be created:
+    # * reference a checkbox (identifier_object, identifier_checkbox)
+    # * check for existence (identifier?, identifier_exists?)
+    # * check for visibility (identifier_?, identifier_visible?)
+    # * check for enabled (identifier!, identifier_enabled?)
+    # * check for checked (identifier_checked?)
+    # * set checked state (check_identifier)
+    # * set unchecked state (uncheck_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::CheckBox
+    def checkbox(identifier, locator)
+      define_method("#{identifier}_object") do
+        @platform.get_checkbox_for(locator.clone)
+      end
+      
+      alias_method "#{identifier}_checkbox".to_sym, "#{identifier}_object".to_sym
+      
+      define_method("check_#{identifier}") do
+        @platform.check_checkbox_for(locator.clone)
+      end
+      
+      define_method("uncheck_#{identifier}") do
+        @platform.uncheck_checkbox_for(locator.clone)
+      end
+      
+      define_method("#{identifier}_checked?") do
+        @platform.check_checkbox_for_checked(locator.clone)
+      end
+      
+      define_method("#{identifier}_exists?") do
+        @platform.check_checkbox_for_existence(locator.clone)
+      end
+      
+      alias_method "#{identifier}?".to_sym, "#{identifier}_exists?".to_sym
+      
+      define_method("#{identifier}_visible?") do
+        @platform.check_checkbox_for_visibility(locator.clone)
+      end
+      
+      alias_method "#{identifier}_?".to_sym, "#{identifier}_visible?".to_sym
+      
+      define_method("#{identifier}_enabled?") do
+        @platform.check_checkbox_for_enabled(locator.clone)
+      end
+      
+      alias_method "#{identifier}!".to_sym, "#{identifier}_enabled?".to_sym
+    end
+    
+    # Definition method for radios. Methods for the following actions will be created:
+    # * reference a radio (identifier_object, identifier_radio, identifier_radio_button)
+    # * check for existence (identifier?, identifier_exists?)
+    # * check for visibility (identifier_?, identifier_visible?)
+    # * check for enabled (identifier!, identifier_enabled?)
+    # * check for selected (identifier_set?, identifier_selected?)
+    # * set selected state (set_identifier, select_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::Radio
+    def radio(identifier, locator)
+      define_method("#{identifier}_object") do
+        @platform.get_radio_for(locator.clone)
+      end
+      
+      alias_method "#{identifier}_radio".to_sym, "#{identifier}_object".to_sym
+      alias_method "#{identifier}_radio_button".to_sym, "#{identifier}_object".to_sym
+      
+      define_method("#{identifier}_selected?") do
+        @platform.check_radio_for_selected(locator.clone)
+      end
+      
+      alias_method "#{identifier}_set?".to_sym, "#{identifier}_selected?".to_sym
+      
+      define_method("select_#{identifier}") do
+        @platform.select_radio_for(locator.clone)
+      end
+      
+      alias_method "set_#{identifier}".to_sym, "select_#{identifier}".to_sym
+      
+      define_method("#{identifier}_exists?") do
+        @platform.check_radio_for_existence(locator.clone)
+      end
+      
+      alias_method "#{identifier}?".to_sym, "#{identifier}_exists?".to_sym
+      
+      define_method("#{identifier}_visible?") do
+        @platform.check_radio_for_visibility(locator.clone)
+      end
+      
+      alias_method "#{identifier}_?".to_sym, "#{identifier}_visible?".to_sym
+      
+      define_method("#{identifier}_enabled?") do
+        @platform.check_radio_for_enabled(locator.clone)
+      end
+      
+      alias_method "#{identifier}!".to_sym, "#{identifier}_enabled?".to_sym
+    end
+    
+    # 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)
+      end
+      
+      alias_method "#{identifier}_?".to_sym, "#{identifier}_visible?".to_sym
+    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)
+      end
+    end
+    
+    # Definition method for div objects. Methods for the following actions will be created:
+    # * reference a div (identifier_object, identifier_div)
+    # * check for existence (identifier?, identifier_exists?)
+    # * check for visibility (identifier_?, identifier_visible?)
+    # * get text from div (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::Div
+    def div(identifier, locator)
+      define_method("#{identifier}_object") do
+        @platform.get_div_for(locator.clone)
+      end
+      
+      alias_method "#{identifier}_div".to_sym, "#{identifier}_object".to_sym
+      
+      define_method("#{identifier}_exists?") do
+        @platform.check_div_for_existence(locator.clone)
+      end
+      
+      alias_method "#{identifier}?".to_sym, "#{identifier}_exists?".to_sym
+      
+      define_method("#{identifier}_visible?") do
+        @platform.check_div_for_visibility(locator.clone)
+      end
+      
+      alias_method "#{identifier}_?".to_sym, "#{identifier}_visible?".to_sym
+      
+      define_method("#{identifier}") do
+        @platform.get_div_text_for(locator.clone)
+      end
+    end
+    
+    # Definition method for span objects. Methods for the following actions will be created:
+    # * reference a span (identifier_object, identifier_span)
+    # * check for existence (identifier?, identifier_exists?)
+    # * check for visibility (identifier_?, identifier_visible?)
+    # * get text from span (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::Span
+    def span(identifier, locator)
+      define_method("#{identifier}_object") do
+        @platform.get_span_for(locator.clone)
+      end
+      
+      alias_method "#{identifier}_span".to_sym, "#{identifier}_object".to_sym
+      
+      define_method("#{identifier}_exists?") do
+        @platform.check_span_for_existence(locator.clone)
+      end
+      
+      alias_method "#{identifier}?".to_sym, "#{identifier}_exists?".to_sym
+      
+      define_method("#{identifier}_visible?") do
+        @platform.check_span_for_visibility(locator.clone)
+      end
+      
+      alias_method "#{identifier}_?".to_sym, "#{identifier}_visible?".to_sym
+      
+      define_method("#{identifier}") do
+        @platform.get_span_text_for(locator.clone)
+      end
+    end
   end # module: Generators
 end # module: Symbiont

data/lib/symbiont/platform_watir/platform_object.rb

@@ -119,6 +119,223 @@ module Symbiont
           access_web_object("text_field(locator).enabled?", locator)
         end
         
+        # Platform method to return a select list object.
+        # Select list objects are of type: Symbiont::WebObjects::SelectList
+        # @see Symbiont::Generators#select_list
+        def get_select_list_for(locator)
+          reference_web_object("select_list(locator)", WebObjects::SelectList, locator)
+        end
+        
+        # Platform method to retrieve the text of the current selection from a select list object.
+        # @see Symbiont::Generators#select_list
+        def get_select_list_item_for(locator)
+          access_web_object("select_list(locator).selected_options[0].text", locator)
+        end
+        
+        # Platform method to retrieve the value of the current selection from a select list object.
+        # @see Symbiont::Generators#select_list
+        def get_select_list_value_for(locator)
+          access_web_object("select_list(locator).value", locator)
+        end
+        
+        # Platform method to set the value of a select list object.
+        # @see Symbiont::Generators#select_list
+        def set_select_list_value_for(locator, value)
+          access_web_object("select_list(locator).select(value)", locator, value)
+        end
+        
+        # Platform method to check if select_list object exists.
+        # @see Symbiont::Generators#select_list
+        def check_select_list_for_existence(locator)
+          access_web_object("select_list(locator).exists?", locator)
+        end
+        
+        # Platform method to check if select list object is visible.
+        # @see Symbiont::Generators#select_list
+        def check_select_list_for_visibility(locator)
+          access_web_object("select_list(locator).visible?", locator)
+        end
+        
+        # Platform method to check if select list object is enabled.
+        # @see Symbiont::Generators#select_list
+        def check_select_list_for_enabled(locator)
+          access_web_object("select_list(locator).enabled?", locator)
+        end
+        
+        # Platform method to return a checkbox object.
+        # Checkbox objects are of type: Symbiont::WebObjects::CheckBox
+        # @see Symbiont::Generators#checkbox
+        def get_checkbox_for(locator)
+          reference_web_object("checkbox(locator)", WebObjects::CheckBox, locator)
+        end
+        
+        # Platform method to check if checkbox object exists.
+        # @see Symbiont::Generators#checkbox
+        def check_checkbox_for_existence(locator)
+          access_web_object("checkbox(locator).exists?", locator)
+        end
+        
+        # Platform method to check if checkbox object is visible.
+        # @see Symbiont::Generators#checkbox
+        def check_checkbox_for_visibility(locator)
+          access_web_object("checkbox(locator).visible?", locator)
+        end
+        
+        # Platform method to check if checkbox object is enabled.
+        # @see Symbiont::Generators#checkbox
+        def check_checkbox_for_enabled(locator)
+          access_web_object("checkbox(locator).enabled?", locator)
+        end
+        
+        # Platform method to determine if a checkbox is checked.
+        # @see Symbiont::Generators#checkbox
+        def check_checkbox_for_checked(locator)
+          access_web_object("checkbox(locator).set?", locator)
+        end
+        
+        # Platform method to check a checkbox object.
+        # @see Symbiont::Generators#checkbox
+        def check_checkbox_for(locator)
+          access_web_object("checkbox(locator).set", locator)
+        end
+        
+        # Platform method to uncheck a checkbox object.
+        # @see Symbiont::Generators#checkbox
+        def uncheck_checkbox_for(locator)
+          access_web_object("checkbox(locator).clear", locator)
+        end
+        
+        # Platform method to return a radio object.
+        # Radio objects are of type: Symbiont::WebObjects::Radio
+        # @see Symbiont::Generators#radio
+        def get_radio_for(locator)
+          reference_web_object("radio(locator)", WebObjects::Radio, locator)
+        end
+        
+        # Platform method to check if radio object exists.
+        # @see Symbiont::Generators#radio
+        def check_radio_for_existence(locator)
+          access_web_object("radio(locator).exists?", locator)
+        end
+        
+        # Platform method to check if radio object is visible.
+        # @see Symbiont::Generators#radio
+        def check_radio_for_visibility(locator)
+          access_web_object("radio(locator).visible?", locator)
+        end
+        
+        # Platform method to check if radio object is enabled.
+        # @see Symbiont::Generators#radio
+        def check_radio_for_enabled(locator)
+          access_web_object("radio(locator).enabled?", locator)
+        end
+        
+        # Platform method to determine if a radio is selected.
+        # @see Symbiont::Generators#radio
+        def check_radio_for_selected(locator)
+          access_web_object("radio(locator).set?", locator)
+        end
+        
+        # Platform method to select a radio object.
+        # @see Symbiont::Generators#radio
+        def select_radio_for(locator)
+          access_web_object("radio(locator).set", locator)
+        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)
+        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?", 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?", 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)
+        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?", 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?", 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", locator)
+        end
+        
+        # Platform method to return a div object.
+        # Div objects are of type: Symbiont::WebObjects::Div
+        # @see Symbiont::Generators#div
+        def get_div_for(locator)
+          reference_web_object("div(locator)", WebObjects::Div, locator)
+        end
+        
+        # Platform method to check if div object exists.
+        # @see Symbiont::Generators#div
+        def check_div_for_existence(locator)
+          access_web_object("div(locator).exists?", locator)
+        end
+        
+        # Platform method to check if div object is visible.
+        # @see Symbiont::Generators#div
+        def check_div_for_visibility(locator)
+          access_web_object("div(locator).visible?", locator)
+        end
+        
+        # Platform method to get text of div object.
+        # @see Symbiont::Generators#div
+        def get_div_text_for(locator)
+          access_web_object("div(locator).text", locator)
+        end
+        
+        # Platform method to return a span object.
+        # Span objects are of type: Symbiont::WebObjects::Span
+        # @see Symbiont::Generators#span
+        def get_span_for(locator)
+          reference_web_object("span(locator)", WebObjects::Span, locator)
+        end
+        
+        # Platform method to check if span object exists.
+        # @see Symbiont::Generators#span
+        def check_span_for_existence(locator)
+          access_web_object("span(locator).exists?", locator)
+        end
+        
+        # Platform method to check if span object is visible.
+        # @see Symbiont::Generators#span
+        def check_span_for_visibility(locator)
+          access_web_object("span(locator).visible?", locator)
+        end
+        
+        # Platform method to get text of span object.
+        # @see Symbiont::Generators#span
+        def get_span_text_for(locator)
+          access_web_object("span(locator).text", locator)
+        end
+        
         private
         
         # This method is called by any platform methods that require getting

data/lib/symbiont/version.rb

@@ -1,3 +1,3 @@
 module Symbiont
-  VERSION = "0.0.4"
+  VERSION = "0.1.0"
 end

data/lib/symbiont/web_objects/_common.rb

@@ -1,11 +1,32 @@
 module Symbiont
   module WebObjects
-
+    
+    # This class is designed to provide methods for functionality that is
+    # common to all web objects and that may need to be called directly
+    # on a web object (as opposed to a web object wrapped up by the
+    # platform).
+    
     class WebObject
       def initialize(web_object)
         @web_object = web_object
       end
       
+      def enabled?
+        @web_object.enabled?
+      end
+      
+      def disabled?
+        not enabled?
+      end
+      
+      def exists?
+        @web_object.exists?
+      end
+      
+      def visible?
+        @web_object.visible?
+      end
+      
       def text
         @web_object.text
       end

data/lib/symbiont/web_objects/checkbox.rb

@@ -0,0 +1,9 @@
+module Symbiont
+  module WebObjects
+
+    class CheckBox < WebObject
+
+    end # class: CheckBox
+
+  end # module: WebObjects
+end # module: Symbiont

data/lib/symbiont/web_objects/div.rb

@@ -0,0 +1,9 @@
+module Symbiont
+  module WebObjects
+    
+    class Div < WebObject
+      
+    end # class: Div
+    
+  end # module: WebObjects
+end # module: Symbiont

data/lib/symbiont/web_objects/radio.rb

@@ -0,0 +1,9 @@
+module Symbiont
+  module WebObjects
+    
+    class Radio < WebObject
+      
+    end # class: Radio
+    
+  end # module: WebObjects
+end # module: Symbiont

data/lib/symbiont/web_objects/select_list.rb

@@ -0,0 +1,9 @@
+module Symbiont
+  module WebObjects
+    
+    class SelectList < WebObject
+      
+    end # class: SelectList
+    
+  end # module: WebObjects
+end # module: Symbiont

data/lib/symbiont/web_objects/span.rb

@@ -0,0 +1,9 @@
+module Symbiont
+  module WebObjects
+    
+    class Span < WebObject
+      
+    end # class: Span
+    
+  end # module: WebObjects
+end # module: Symbiont

data/lib/symbiont/web_objects/table.rb

@@ -0,0 +1,38 @@
+module Symbiont
+  module WebObjects
+    
+    class Table < WebObject
+      
+      # This method is used to return a TableRow object based on the index provided.
+      # @return [Symbiont::WebObjects::TableRow]
+      def [](index)
+        Object::Symbiont::WebObjects::TableRow.new(@web_object[index])
+      end
+      
+      # This method will return the number of rows in a table.
+      def rows
+        @web_object.wd.find_elements(:xpath, row_xpath).size
+      end
+      
+      # Returns a reference to the first row web object of a table.
+      # @return [Symbiont::WebObjects::TableRow]
+      def first_row
+        self[0]
+      end
+      
+      # Returns a reference to the last row web object of a table.
+      # @return [Symbiont::WebObjects::TableRow]
+      def last_row
+        self[-1]
+      end
+      
+      protected
+      
+      def row_xpath
+        ".//child::tr"
+      end
+      
+    end # class: Table
+    
+  end # module: WebObjects
+end # module: Symbiont

data/lib/symbiont/web_objects/table_cell.rb

@@ -0,0 +1,9 @@
+module Symbiont
+  module WebObjects
+    
+    class TableCell < WebObject
+      
+    end # class: TableCell
+    
+  end # module: WebObjects
+end # module: Symbiont