symbiont 0.1.9 → 0.2.0

data/lib/symbiont/generators.rb

@@ -15,7 +15,7 @@ module Symbiont
 
     def title_is(title)
       define_method('has_title?') do
-        sleep 1
+        wait_for_app
         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
@@ -23,59 +23,101 @@ module Symbiont
       end
     end
     
-    def look_for(widget, timeout=5)
+    def look_for(widget, timeout=::Symbiont.element_level_wait)
       define_method('has_object?') do
         if self.respond_to? "#{widget}_object"
           self.send("#{widget}_object").when_actionable(timeout)
         else
-          puts "The #{widget} object was not declared and could not be checked."
+          raise "\n\nThe '#{widget}' object was not declared and could not be checked."
         end
       end
     end
 
-    def paragraph(identifier, locator)
+    def frame(locator, encloser=nil, &block)
+      encloser = [] if encloser.nil?
+      encloser << locator
+      block.call(encloser)
+    end
+
+    def paragraph(identifier, locator={index: 0}, &block)
       define_method(identifier) do
-        platform.paragraph_text_for(locator.clone)
+        return platform.paragraph_text_for(locator.clone) unless block_given?
+        self.send("#{identifier}_object").text
       end
 
-      common_definition_methods(identifier, locator, 'paragraph_element')
+      common_definition_methods(identifier, locator, 'paragraph_element', &block)
     end
 
     alias_method :p, :paragraph
 
-    def link(identifier, locator)
+    def link(identifier, locator={index: 0}, &block)
       define_method(identifier) do
-        platform.click_link_for(locator.clone)
+        return platform.click_link_for(locator.clone) unless block_given?
+        self.send("#{identifier}_object").click
       end
 
-      common_definition_methods(identifier, locator, 'link_element')
+      common_definition_methods(identifier, locator, 'link_element', &block)
     end
 
     alias_method :a, :link
 
-    def button(identifier, locator)
+    def button(identifier, locator={index: 0}, &block)
       define_method(identifier) do
-        platform.click_button_for(locator.clone)
+        return platform.click_button_for(locator.clone) unless block_given?
+        self.send("#{name}_object").click
       end
 
-      common_definition_methods(identifier, locator, 'button_element')
+      common_definition_methods(identifier, locator, 'button_element', &block)
     end
 
-    def text_field(identifier, locator)
+    def text_field(identifier, locator={index: 0}, &block)
       define_method(identifier) do
-        platform.get_text_field_value_for(locator.clone)
+        return platform.get_text_field_value_for(locator.clone) unless block_given?
+        self.send("#{identifier}_object").value
       end
 
       define_method("#{identifier}=") do |value|
-        platform.set_text_field_value_for(locator.clone, value)
+        return platform.set_text_field_value_for(locator.clone, value) unless block_given?
+        self.send("#{identifier}_object").value = value
       end
 
-      common_definition_methods(identifier, locator, 'text_field_element')
+      common_definition_methods(identifier, locator, 'text_field_element', &block)
     end
-    
-    def select_list(identifier, locator)
+
+    alias_method :textfield, :text_field
+    alias_method :text, :text_field
+
+    def text_area(identifier, locator={index: 0}, &block)
       define_method(identifier) do
-        platform.get_select_list_item_for(locator.clone)
+        return platform.get_text_area_value_for(locator.clone) unless block_given?
+        self.send("#{identifier}_object").value
+      end
+
+      define_method("#{identifier}=") do |value|
+        return platform.set_text_area_value_for(locator.clone, value) unless block_given?
+        self.send("#{identifier}_object").value = value
+      end
+
+      common_definition_methods(identifier, locator, 'text_area_element', &block)
+    end
+
+    alias_method :textarea, :text_area
+
+    def hidden_field(identifier, locator={index: 0}, &block)
+      define_method(identifier) do
+        return platform.get_hidden_field_value_for(locator.clone) unless block_given?
+        self.send("#{identifier}_object").value
+      end
+
+      common_definition_methods(identifier, locator, 'hidden_field_element', &block)
+    end
+
+    alias_method :hidden, :hidden_field
+
+    def select_list(identifier, locator={index: 0}, &block)
+      define_method(identifier) do
+        return platform.get_select_list_item_for(locator.clone) unless block_given?
+        self.send("#{identifier}_object").value
       end
       
       define_method("#{identifier}_option?") do
@@ -88,105 +130,191 @@ module Symbiont
       end
 
       define_method("#{identifier}=") do |value|
-        platform.set_select_list_value_for(locator.clone, value)
+        return platform.set_select_list_value_for(locator.clone, value) unless block_given?
+        self.send("#{identifier}_object").select(value)
       end
 
-      common_definition_methods(identifier, locator, 'select_list_element')
+      common_definition_methods(identifier, locator, 'select_list_element', &block)
     end
 
     alias_method :select, :select_list
     
-    def checkbox(identifier, locator)
+    def checkbox(identifier, locator={index: 0}, &block)
       define_method("check_#{identifier}") do
-        platform.check_checkbox_for(locator.clone)
+        return platform.check_checkbox_for(locator.clone) unless block_given?
+        self.send("#{identifier}_object").check
       end
       
       define_method("uncheck_#{identifier}") do
-        platform.uncheck_checkbox_for(locator.clone)
+        return platform.uncheck_checkbox_for(locator.clone) unless block_given?
+        self.send("#{identifier}_object").uncheck
       end
       
       define_method("#{identifier}_checked?") do
-        platform.check_checkbox_for_checked(locator.clone)
+        return platform.check_checkbox_for_checked(locator.clone) unless block_given?
+        self.send("#{identifier}_object").checked?
       end
 
-      common_definition_methods(identifier, locator, 'checkbox_element')
+      common_definition_methods(identifier, locator, 'checkbox_element', &block)
     end
     
-    def radio(identifier, locator)
+    def radio(identifier, locator={index: 0}, &block)
       #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)
+        return platform.check_radio_for_selected(locator.clone) unless block_given?
+        self.send("#{identifier}_object").selected?
       end
       
       alias_method "#{identifier}_set?".to_sym, "#{identifier}_selected?".to_sym
       
       define_method("select_#{identifier}") do
-        platform.select_radio_for(locator.clone)
+        return platform.select_radio_for(locator.clone) unless block_given?
+        self.send("#{identifier}_object").select
       end
       
       alias_method "set_#{identifier}".to_sym, "select_#{identifier}".to_sym
 
-      common_definition_methods(identifier, locator, 'radio_element')
+      common_definition_methods(identifier, locator, 'radio_element', &block)
     end
 
     alias_method :radio_button, :radio
 
+    def table(identifier, locator={index: 0}, &block)
+      define_method(identifier) do
+        return platform.table_text_for(locator.clone) unless block_given?
+        self.send("#{identifier}_object").text
+      end
 
+      common_definition_methods(identifier, locator, 'table_element', &block)
+    end
+    
+    def cell(identifier, locator={index: 0}, &block)
+      define_method(identifier) do
+        return platform.get_table_cell_text_for(locator.clone) unless block_given?
+        self.send("#{identifier}_object").text
+      end
 
+      common_definition_methods(identifier, locator, 'cell_element', &block)
+    end
 
+    alias_method :td, :cell
 
-    def table(identifier, locator)
+    def div(identifier, locator={index: 0}, &block)
       define_method(identifier) do
-        platform.table_text_for(locator.clone)
+        return platform.div_text_for(locator.clone) unless block_given?
+        self.send("#{identifier}_object").text
       end
 
-      common_definition_methods(identifier, locator, 'table_element')
+      common_definition_methods(identifier, locator, 'div_element', &block)
     end
     
-    def cell(identifier, locator)
+    def span(identifier, locator={index: 0}, &block)
       define_method(identifier) do
-        platform.get_table_cell_text_for(locator.clone)
+        return platform.span_text_for(locator.clone) unless block_given?
+        self.send("#{identifier}_object").text
       end
 
-      common_definition_methods(identifier, locator, 'cell_element')
+      common_definition_methods(identifier, locator, 'span_element', &block)
     end
 
-    def div(identifier, locator)
+    def h1(identifier, locator={index: 0}, &block)
       define_method(identifier) do
-        platform.div_text_for(locator.clone)
+        return platform.h1_text_for(locator.clone) unless block_given?
+        self.send("#{identifier}_object").text
       end
 
-      common_definition_methods(identifier, locator, 'div_element')
+      common_definition_methods(identifier, locator, 'h1_element', &block)
     end
-    
-    def span(identifier, locator)
+
+    def h2(identifier, locator={index: 0}, &block)
       define_method(identifier) do
-        platform.span_text_for(locator.clone)
+        return platform.h2_text_for(locator.clone) unless block_given?
+        self.send("#{identifier}_object").text
       end
 
-      common_definition_methods(identifier, locator, 'span_element')
+      common_definition_methods(identifier, locator, 'h2_element', &block)
+    end
+
+    def label(identifier, locator={index: 0}, &block)
+      define_method(identifier) do
+        return platform.label_text_for(locator.clone) unless block_given?
+        self.send("#{identifier}_object").text
+      end
+
+      common_definition_methods(identifier, locator, 'label_element', &block)
+    end
+
+    def ordered_list(identifier, locator={:index => 0}, &block)
+      define_method(identifier) do
+        return platform.ordered_list_text_for(locator.clone) unless block_given?
+        self.send("#{identifier}_object").text
+      end
+
+      common_definition_methods(identifier, locator, 'ordered_list_element', &block)
+    end
+
+    alias_method :ol, :ordered_list
+
+    def unordered_list(identifier, locator={:index => 0}, &block)
+      define_method(identifier) do
+        return platform.unordered_list_text_for(locator.clone) unless block_given?
+        self.send("#{identifier}_object").text
+      end
+
+      common_definition_methods(identifier, locator, 'unordered_list_element', &block)
+    end
+
+    alias_method :ul, :unordered_list
+
+    def list_item(identifier, locator={:index => 0}, &block)
+      define_method(identifier) do
+        return platform.list_item_text_for(locator.clone) unless block_given?
+        self.send("#{identifier}_object").text
+      end
+
+      common_definition_methods(identifier, locator, 'list_item_element', &block)
+    end
+
+    alias_method :li, :list_item
+
+    ## Multiple Element Handling ##
+
+    [:unordered_lists, :ordered_lists, :list_items].each do |method|
+      define_method(method) do |identifier, *locator, &block|
+        define_method("#{identifier}_elements") do
+          return process_block(&block) unless block.nil?
+          platform_method = "#{method.to_s}_elements"
+          puts "*********** #{platform_method}"
+          platform.send(platform_method, locator.first.clone)
+        end
+      end
     end
 
-    def common_definition_methods(identifier, locator, method)
+    def common_definition_methods(identifier, locator, method, &block)
       define_method("#{identifier}_object") do
+        return process_block(&block) if block_given?
         platform.send(method, locator.clone)
       end
 
       define_method("#{identifier}_exists?") do
+        return process_block(&block).exists? if block_given?
         platform.send(method, locator.clone).exists?
       end
 
       define_method("#{identifier}_visible?") do
+        return process_block(&block).visible? if block_given?
         platform.send(method, locator.clone).visible?
       end
 
       define_method("#{identifier}_enabled?") do
+        return process_block(&block).enabled? if block_given?
         platform.send(method, locator.clone).enabled?
       end
 
       define_method("#{identifier}_text") do
+        return process_block(&block).text if block_given?
         platform.send(method, locator.clone).text
       end
 

data/lib/symbiont/platform_watir/platform_object.rb

@@ -29,6 +29,18 @@ module Symbiont
         def back
           @browser.back
         end
+
+        def forward
+          @browser.forward
+        end
+
+        def refresh
+          @browser.refresh
+        end
+
+        def remove_cookies
+          @browser.cookies.clear
+        end
         
         ## Page-Level Actions ##
         
@@ -67,30 +79,61 @@ module Symbiont
           @browser.window(identifier).use(&block)
         end
 
+        def within_frame(locator, encloser=nil, &block)
+          encloser = [] if encloser.nil?
+          encloser << locator
+          block.call(encloser)
+        end
+
         # Platform method to handle an alert message box.
         # @see Symbiont::Enclosers#will_alert
-        def will_alert(&block)
-          @browser.wd.execute_script("window.alert = function(msg) { window.__lastWatirAlert=msg; }")
+        def will_alert(encloser=nil, &block)
+          switch_to_frame(encloser)
+
           yield
-          value = @browser.wd.execute_script("return window.__lastWatirAlert")
+          value = nil
+          if @browser.alert.exists?
+            value = @browser.alert.text
+            @browser.alert.ok
+          end
+
+          ###
+          ##@browser.wd.execute_script("window.alert = function(msg) { window.__lastWatirAlert=msg; }")
+          ##yield
+          ##value = @browser.wd.execute_script("return window.__lastWatirAlert")
+
+          switch_to_default_content(encloser)
           value
         end
         
         # Platform method to handle a confirmation message box
         # @see Symbiont::Enclosers#will_confirm
-        def will_confirm(response, &block)
-          @browser.wd.execute_script("window.confirm = function(msg) { window.__lastWatirConfirm=msg; return #{!!response} }")
+        def will_confirm(response, encloser=nil, &block)
+          switch_to_frame(encloser)
+
           yield
-          value = @browser.wd.execute_script("return window.__lastWatirConfirm")
+          value = nil
+          if @browser.alert.exists?
+            value = @browser.alert.text
+            response ? @browser.alert.ok : @browser.alert.close
+          end
+
+          ##@browser.wd.execute_script("window.confirm = function(msg) { window.__lastWatirConfirm=msg; return #{!!response} }")
+          ##yield
+          ##value = @browser.wd.execute_script("return window.__lastWatirConfirm")
+
+          switch_to_default_content(encloser)
           value
         end
         
         # Platform method to handle a prompt message box.
         # @see Symbiont::Enclosers#will_prompt
-        def will_prompt(response, &block)
+        def will_prompt(response, encloser=nil, &block)
+          switch_to_frame(encloser)
           @browser.wd.execute_script("window.prompt = function(text, value) { window.__lastWatirPrompt = { message: text, default_value: value }; return #{!!response}; }")
           yield
           result = @browser.wd.execute_script("return window.__lastWatirPrompt")
+          switch_to_default_content(encloser)
           result && result.dup.each_key { |k| result[k.to_sym] = result.delete(k) }
           result
         end
@@ -107,6 +150,16 @@ module Symbiont
           access_web_object("p(locator).text", WebObjects::Paragraph, locator, nil, 'p')
         end
 
+        ## Labels ##
+
+        def label_element(locator)
+          reference_web_object("label(locator)", WebObjects::Label, locator, 'label')
+        end
+
+        def label_text_for(locator)
+          access_web_object("label(locator).text", WebObjects::Label, locator, nil, 'label')
+        end
+
         ## Links ##
 
         def link_element(locator)
@@ -141,6 +194,30 @@ module Symbiont
           access_web_object("text_field(locator).set(value)", WebObjects::TextField, locator, value)
         end
 
+        ## Text Areas ##
+
+        def text_area_element(locator)
+          reference_web_object("text_area(locator)", WebObjects::TextArea, locator)
+        end
+
+        def get_text_area_value_for(locator)
+          access_web_object("text_area(locator).value", WebObjects::TextArea, locator)
+        end
+
+        def set_text_area_value_for(locator, value)
+          access_web_object("text_area(locator).set(value)", WebObjects::TextArea, locator, value)
+        end
+
+        ## Hidden Fields ##
+
+        def hidden_field_element(locator)
+          reference_web_object("hidden(locator)", WebObjects::HiddenField, locator)
+        end
+
+        def get_hidden_field_value_for(locator)
+          access_web_object("hidden(locator).value", WebObjects::HiddenField, locator)
+        end
+
         ## Checkboxes ##
 
         def checkbox_element(locator)
@@ -167,6 +244,7 @@ module Symbiont
         
         def get_select_list_item_for(locator)
           access_web_object("select_list(locator).selected_options[0].text", WebObjects::SelectList, locator)
+          # Should I consider: select_list(identifier).options.find {|o| o.selected?}.text
         end
         
         def get_select_list_value_for(locator)
@@ -191,6 +269,8 @@ module Symbiont
           access_web_object("radio(locator).set", WebObjects::Radio, locator)
         end
 
+        ## Table Elements ##
+
         def table_element(locator)
           reference_web_object("table(locator)", WebObjects::Table, locator, 'table')
         end
@@ -199,7 +279,6 @@ module Symbiont
           access_web_object("table(locator).text", WebObjects::Table, locator, nil, 'table')
         end
 
-
         def cell_element(locator)
           reference_web_object("td(locator)", WebObjects::TableCell, locator, 'td')
         end
@@ -208,6 +287,8 @@ module Symbiont
           access_web_object("td(locator).text", WebObjects::TableCell, locator, nil, 'td')
         end
 
+        ## Sectional Elements ##
+
         def div_element(locator)
           reference_web_object("div(locator)", WebObjects::Div, locator, 'div')
         end
@@ -224,7 +305,63 @@ module Symbiont
           access_web_object("span(locator).text", WebObjects::Span, locator, nil, 'span')
         end
 
-        private
+        ## Header Elements ##
+
+        def h1_element(locator)
+          reference_web_object("h1(locator)", WebObjects::Heading, locator, 'h1')
+        end
+
+        def h1_text_for(locator)
+          access_web_object("h1(locator).text", WebObjects::Heading, locator, nil, 'h1')
+        end
+
+        def h2_element(locator)
+          reference_web_object("h2(locator)", WebObjects::Heading, locator, 'h2')
+        end
+
+        def h2_text_for(locator)
+          access_web_object("h2(locator).text", WebObjects::Heading, locator, nil, 'h2')
+        end
+
+        ## List Elements ##
+
+        def ordered_list_element(locator)
+          reference_web_object("ol(locator)", WebObjects::OrderedList, locator, 'ol')
+        end
+
+        def ordered_list_text_for(locator)
+          access_web_object("ol(locator).text", WebObjects::OrderedList, locator, nil, 'ol')
+        end
+
+        def ordered_lists_elements(locator)
+          reference_web_object("ols(locator)", WebObjects::OrderedList, locator, 'ol')
+        end
+
+        def unordered_list_element(locator)
+          reference_web_object("ul(locator)", WebObjects::UnorderedList, locator, 'ul')
+        end
+
+        def unordered_list_text_for(locator)
+          access_web_object("ul(locator).text", WebObjects::UnorderedList, locator, nil, 'ul')
+        end
+
+        def unordered_lists_elements(locator)
+          reference_web_object("uls(locator)", WebObjects::UnorderedList, locator, 'ul')
+        end
+
+        def list_item_element(locator)
+          reference_web_object("li(locator)", WebObjects::ListItem, locator, 'li')
+        end
+
+        def list_item_text_for(locator)
+          access_web_object("li(locator).text", WebObjects::ListItem, locator, nil, 'li')
+        end
+
+        def list_items_elements(locator)
+          reference_web_object("lis(locator)", WebObjects::ListItem, locator, 'li')
+        end
+
+      private
         
         # This method is called by any platform methods that require getting
         # an object reference.
@@ -234,10 +371,11 @@ module Symbiont
         # @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, object_tag=nil)
-          enclosers = locator.delete(:frame)
-          locator = object_type.provide_locator_for(locator)
+          #puts "[ref_obj] Locator (1): #{locator}"
+          locator, enclosers = qualify_locators(locator, object_type, object_tag)
+          #puts "[ref_obj] Locator (2): #{locator}"
           web_object = @browser.instance_eval "#{enclosed_by(enclosers)}#{action}"
-          @browser.wd.switch_to.default_content unless enclosers.nil?
+          switch_to_default_content(enclosers)
           object_type.new(web_object)
         end
         
@@ -247,17 +385,50 @@ module Symbiont
         #
         # @param [String] action the driver logic to be sent to the browser
         # @param [Hash] locator the specific web object selector, mainly for parsing
-        # @param [String] value any specific information that must be sent to the
-        # web object
+        # @param [String] value any specific information that must be sent to the web object
+        # @param [String] object_tag the tag that represents the web object in a browser
+        #
         # @return [Any] the information or object returned by the action
         def access_web_object(action, object_type, locator, value=nil, object_tag=nil)
+          #puts "[acc_obj] Locator (1): #{locator}"
+          locator, enclosers = qualify_locators(locator, object_type, object_tag)
+          #puts "[acc_obj] Locator (2): #{locator}"
+          web_object = @browser.instance_eval "#{enclosed_by(enclosers)}#{action}"
+          switch_to_default_content(enclosers)
+          web_object
+        end
+
+        # This method is used to qualify any locators with necessary information that
+        # is required to find the web objects during execution.
+        #
+        # @param [String] locator the locator being used
+        # @param [Object] object_type the object type that the locator applies to
+        # @param [String] object_tag the tag that represents the web object in a browser
+        def qualify_locators(locator, object_type, object_tag=nil)
           enclosers = locator.delete(:frame)
+
+          #puts "[qualify] Locator (1): #{locator}"
+          locator = use_tagname_for_name(locator, object_tag) if object_tag
+          #puts "[qualify] Locator (2): #{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
+          #puts "[qualify] Locator (3): #{locator}"
+
+          return locator, enclosers
         end
-        
+
+        # This method uses an object tag for the locator for a web object
+        # if the locator being used was :name.
+        #
+        # @param [String] locator the locator being used
+        # @param [String] object_tag the tag that represents the web object in a browser
+        def use_tagname_for_name(locator, object_tag)
+          #puts "[use_tagname] Locator (1): #{locator}"
+          return locator if locator.length < 2 and not locator[:name]
+          locator[:tag_name] = object_tag if locator[:name]
+          #puts "[use_tagname] Locator (2): #{locator}"
+          locator
+        end
+
         # This method is used to wrap a web object locator within the locator for an
         # enclosing web object. Currently the only enclosing objects this makes sense
         # for are iframes and frames.
@@ -272,6 +443,19 @@ module Symbiont
           
           encloser_locator = "frame(:#{key} => '#{value}')."
         end
+
+        def switch_to_default_content(locator)
+          @browser.wd.switch_to.default_content unless locator.nil?
+        end
+
+        def switch_to_frame(locator)
+          unless locator.nil?
+            locator.each do |frame|
+              value = frame.values.first
+              @browser.wd.switch_to.frame(value)
+            end
+          end
+        end
       end # class: PlatformObject
 
     end # module: WatirWebDriver

data/lib/symbiont/version.rb

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

data/lib/symbiont/web_objects/button.rb

@@ -8,7 +8,7 @@ module Symbiont
       end
 
       def self.usable_selectors
-        super + [:value, :text, :src, :alt, :css]
+        super + [:value, :text, :src, :alt]
       end
 
     end # class: Button