symbiont 0.1.7 → 0.1.8

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

@@ -0,0 +1,40 @@
+module Symbiont
+  module Platforms
+    module SeleniumWebDriver
+      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)
+          all_rows = table_rows
+          index = find_by_title(index, all_rows) if index.kind_of?(String)
+          return nil unless index
+          ::Symbiont::WebObjects::TableRow.new(all_rows[index], :platform => :selenium_webdriver)
+        end
+
+        # This method will return the number of rows in a table.
+        def rows
+          table_rows.size
+        end
+
+        def find_by_title(row_text, all_rows)
+          all_rows.find_index do |row|
+            columns = row.find_elements(:xpath, ".//child::td|th")
+            columns.any? { |col| col.text.include? row_text }
+          end
+        end
+
+        def table_rows
+          web_object.find_elements(:xpath, row_xpath)
+        end
+
+        def exists?
+          raise "Currently Selenium is not very good at checking if a table exists."
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+module Symbiont
+  module Platforms
+    module SeleniumWebDriver
+      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)
+          all_cells = table_cells
+          index = find_by_title(index) if index.kind_of?(String)
+          return nil unless index && columns >= idx + 1
+          ::Symbiont::WebObjects::TableCell.new(all_cells[index], :platform => :selenium_webdriver)
+        end
+
+        # This method returns the number of columns in a table object.
+        def columns
+          table_cells.size
+        end
+
+        def find_by_title(column_text)
+          table = parent
+          parent_tag = parent.web_object.tag_name
+          table = table.parent if (parent_tag == 'tbody' || parent_tag == 'thead')
+          table[0].find_index { |column| column.text.include? column_text }
+        end
+
+        def table_cells
+          web_object.find_elements(:xpath, cell_xpath)
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+module Symbiont
+  module Platforms
+    module SeleniumWebDriver
+      module TextField
+
+        def value=(value)
+          web_object.clear
+          web_object.send_keys(value)
+        end
+
+      end
+    end
+  end
+end

data/lib/symbiont/platform_watir.rb

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

data/lib/symbiont/platform_watir/platform_object.rb

@@ -10,57 +10,45 @@ module Symbiont
         
         ## Browser-Level Actions ##
         
-        # Platform method to make a call to a specified URL.
-        # See Symbiont#visit
         def visit(url)
           @browser.goto(url)
         end
         
-        # Platform method to get the URL of the active page.
-        # See Symbiont#url
         def url
           @browser.url
         end
         
-        # Platform method to save the current screenshot to a file.
-        # See Symbiont#screenshot
         def screenshot(file)
           @browser.wd.save_screenshot(file)
         end
         
-        # Platform method to run a script against the browser.
-        # See Symbiont#run_script
         def run_script(script)
           @browser.execute_script(script)
         end
+
+        def back
+          @browser.back
+        end
         
         ## Page-Level Actions ##
         
-        # Platform method to retrieve text from the current page.
-        # See Symbiont#text
         def text
           @browser.text
         end
         
-        # Platform method to retrieve markup from the current page.
-        # See Symbiont#markup
         def markup
           @browser.html
         end
 
-        # Platform method to get the title of the current page.
-        # See Symbiont#title
         def title
           @browser.title
         end
         
-        # Platform method to get the web object that has focus.
-        # See Symbiont#focus
         def focus
           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)
+          object_class.new(web_object, :platform => :watir_webdriver)
         end
         
         ## Encloser Methods ##
@@ -108,238 +96,103 @@ module Symbiont
         end
         
         ## Generator Methods ##
-        
-        # Platform method to return a link object.
-        # Link objects are of type: Symbiont::WebObjects::Link
-        # @see Symbiont::Generators#link
-        def get_link_for(locator)
-          action = check_for_css("link(locator)", locator)
-          reference_web_object(action, WebObjects::Link, locator)
-        end
-        
-        # Platform method to get text of link object.
-        # @see Symbiont::Generators#link
-        def get_link_text_for(locator)
-          access_web_object("link(locator).text", WebObjects::Link, locator)
+
+        ## Paragraphs ##
+
+        def paragraph_element(locator)
+          reference_web_object("p(locator)", WebObjects::Paragraph, locator)
         end
 
-        # Platform method to click a link object.
-        # @see Symbiont::Generators#link
-        def click_link_for(locator)
-          action = check_for_css("link(locator)", locator)
-          access_web_object("#{action}.click", WebObjects::Link, locator)
+        def paragraph_text_for(locator)
+          access_web_object("p(locator).text", WebObjects::Paragraph, locator)
         end
 
-        # Platform method to check if link object exists.
-        # @see Symbiont::Generators#link
-        def check_link_for_existence(locator)
-          access_web_object("link(locator).exists?", WebObjects::Link, locator)
+        ## Links ##
+
+        def link_element(locator)
+          reference_web_object("link(locator)", WebObjects::Link, locator)
         end
         
-        # Platform method to check if link object is visible.
-        # @see Symbiont::Generators#link
-        def check_link_for_visibility(locator)
-          access_web_object("link(locator).visible?", WebObjects::Link, locator)
+        def click_link_for(locator)
+          access_web_object("link(locator).click", WebObjects::Link, locator)
         end
-        
-        # Platform method to return a button object.
-        # Button objects are of type: Symbiont::WebObjects::Button
-        # @see Symbiont::Generators#button
-        def get_button_for(locator)
-          action = check_for_css("button(locator)", locator)
+
+        ## Buttons ##
+
+        def button_element(locator)
           reference_web_object("button(locator)", WebObjects::Button, locator)
         end
         
-        # Platform method to get text of button object.
-        # @see Symbiont::Generators#button
-        def get_button_text_for(locator)
-          access_web_object("button(locator).text", WebObjects::Button, locator)
-        end
-        
-        # Platform method to click a button object.
-        # @see Symbiont::Generators#button
         def click_button_for(locator)
-          action = check_for_css("button(locator)", locator)
-          access_web_object("#{action}.click", WebObjects::Button, locator)
+          access_web_object("button(locator).click", WebObjects::Button, locator)
         end
 
-        # Platform method to check if button object exists.
-        # @see Symbiont::Generators#button
-        def check_button_for_existence(locator)
-          access_web_object("button(locator).exists?", WebObjects::Button, locator)
-        end
-        
-        # Platform method to check if button object is visible.
-        # @see Symbiont::Generators#button
-        def check_button_for_visibility(locator)
-          access_web_object("button(locator).visible?", WebObjects::Button, locator)
-        end
-        
-        # Platform method to check if button object is enabled.
-        # @see Symbiont::Generators#button
-        def check_button_for_enabled(locator)
-          access_web_object("button(locator).enabled?", WebObjects::Button, locator)
-        end
+        ## Text Fields ##
 
-        # Platform method to return a text field object.
-        # Text field objects are of type: Symbiont::WebObjects::TextField
-        # @see Symbiont::Generators#text_field
-        def get_text_field_for(locator)
+        def text_field_element(locator)
           reference_web_object("text_field(locator)", WebObjects::TextField, locator)
         end
 
-        # Platform method to retrieve text from a text field object.
-        # @see Symbiont::Generators#text_field
         def get_text_field_value_for(locator)
           access_web_object("text_field(locator).value", WebObjects::TextField, locator)
         end
 
-        # Platform method to enter text into a text field object.
-        # @see Symbiont::Generators#text_field
         def set_text_field_value_for(locator, value)
           access_web_object("text_field(locator).set(value)", WebObjects::TextField, locator, value)
         end
 
-        # Platform method to check if text field object exists.
-        # @see Symbiont::Generators#text_field
-        def check_text_field_for_existence(locator)
-          access_web_object("text_field(locator).exists?", WebObjects::TextField, locator)
+        ## Checkboxes ##
+
+        def checkbox_element(locator)
+          reference_web_object("checkbox(locator)", WebObjects::CheckBox, locator)
         end
-        
-        # Platform method to check if text field object is visible.
-        # @see Symbiont::Generators#text_field
-        def check_text_field_for_visibility(locator)
-          access_web_object("text_field(locator).visible?", WebObjects::TextField, locator)
+
+        def check_checkbox_for_checked(locator)
+          access_web_object("checkbox(locator).set?", WebObjects::CheckBox, locator)
         end
-        
-        # Platform method to check if text field object is enabled.
-        # @see Symbiont::Generators#text_field
-        def check_text_field_for_enabled(locator)
-          access_web_object("text_field(locator).enabled?", WebObjects::TextField, locator)
+
+        def check_checkbox_for(locator)
+          access_web_object("checkbox(locator).set", WebObjects::CheckBox, 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)
+
+        def uncheck_checkbox_for(locator)
+          access_web_object("checkbox(locator).clear", WebObjects::CheckBox, locator)
+        end
+
+        ## Select Lists ##
+
+        def select_list_element(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", WebObjects::SelectList, 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", WebObjects::SelectList, 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)", WebObjects::SelectList, 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?", WebObjects::SelectList, 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?", WebObjects::SelectList, 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?", WebObjects::SelectList, 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?", WebObjects::CheckBox, 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?", WebObjects::CheckBox, 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?", WebObjects::CheckBox, 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?", WebObjects::CheckBox, locator)
-        end
-        
-        # Platform method to check a checkbox object.
-        # @see Symbiont::Generators#checkbox
-        def check_checkbox_for(locator)
-          access_web_object("checkbox(locator).set", WebObjects::CheckBox, locator)
-        end
-        
-        # Platform method to uncheck a checkbox object.
-        # @see Symbiont::Generators#checkbox
-        def uncheck_checkbox_for(locator)
-          access_web_object("checkbox(locator).clear", WebObjects::CheckBox, 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)
+        ## Radios ##
+
+        def radio_element(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?", WebObjects::Radio, 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?", WebObjects::Radio, 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?", WebObjects::Radio, 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?", WebObjects::Radio, locator)
         end
         
-        # Platform method to select a radio object.
-        # @see Symbiont::Generators#radio
         def select_radio_for(locator)
           access_web_object("radio(locator).set", WebObjects::Radio, locator)
         end
+
+
+
         
         # Platform method to return a table object.
         # Table objects are of type: Symbiont::WebObjects::Table
@@ -350,15 +203,15 @@ module Symbiont
         
         # 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
+        #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
+        #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
@@ -369,15 +222,15 @@ module Symbiont
         
         # 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
+        #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
+        #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
@@ -385,56 +238,16 @@ module Symbiont
           access_web_object("td(locator).text", WebObjects::TableCell, 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)
+
+
+        def div_element(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?", WebObjects::Div, 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?", WebObjects::Div, 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", WebObjects::Div, 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)
+
+        def span_element(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?", WebObjects::Span, 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?", WebObjects::Span, 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", WebObjects::Span, locator)
-        end
-        
+
         private
         
         # This method is called by any platform methods that require getting
@@ -446,9 +259,10 @@ module Symbiont
         # @return [Object] the web object identified by the action
         def reference_web_object(action, object_type, locator)
           enclosers = locator.delete(:frame)
-          locator = object_type.provide_locator_for(locator)
+          locator = object_type.provide_watir_locator_for(locator)
           web_object = @browser.instance_eval "#{enclosed_by(enclosers)}#{action}"
-          object_type.new(web_object)
+          @browser.wd.switch_to.default_content unless enclosers.nil?
+          object_type.new(web_object, :platform => :watir_webdriver)
         end
         
         # This method is called by any platform methods that require accessing
@@ -462,12 +276,10 @@ module Symbiont
         # @return [Any] the information or object returned by the action
         def access_web_object(action, object_type, locator, value=nil)
           enclosers = locator.delete(:frame)
-          locator = object_type.provide_locator_for(locator)
-          @browser.instance_eval "#{enclosed_by(enclosers)}#{action}"
-        end
-        
-        def check_for_css(action, locator)
-          locator[:css] ? "element(locator)" : action
+          locator = object_type.provide_watir_locator_for(locator)
+          object = @browser.instance_eval "#{enclosed_by(enclosers)}#{action}"
+          @browser.wd.switch_to.default_content unless enclosers.nil?
+          object
         end
         
         # This method is used to wrap a web object locator within the locator for an