symbiont 0.2.1 → 0.3.0

data/lib/symbiont/data_setter.rb

@@ -1,53 +0,0 @@
-module Symbiont
-	module DataSetter
-		
-		def using(data)
-			data.each do |key, value|
-				use_text_data_with(key, value) if text_settable_for(key) and object_enabled_for(key)
-        use_check_data_with(key, value) if value_checkable_for(key) and object_enabled_for(key)
-        use_select_data_with(key, value) if value_selectable_for(key) and object_enabled_for(key)
-			end
-		end
-
-		alias :using_data :using
-		alias :using_values :using
-		alias :use_data :using
-		alias :use_values :using
-		
-		private
-		
-		def use_text_data_with(key, value)
-			self.send "#{key}=", value
-		end
-		
-    def use_check_data_with(key, value)
-      if value
-        self.send "check_#{key}"
-      else
-        self.send "uncheck_#{key}"
-      end
-    end
-    
-    def use_select_data_with(key, value)
-      self.send "select_#{key}" if value
-    end
-    
-    def text_settable_for(key)
-      respond_to?("#{key}=".to_sym)
-    end
-    
-    def value_checkable_for(key)
-      respond_to?("check_#{key}".to_sym)
-    end
-    
-    def value_selectable_for(key)
-      respond_to?("select_#{key}".to_sym)
-    end
-    
-    def object_enabled_for(key)
-      return true if (self.send "#{key}_object").tag_name == "textarea"
-      self.send("#{key}_object").enabled?
-    end
-    
-	end # module: DataSetter
-end # module: Symbiont

data/lib/symbiont/enclosers.rb

@@ -1,118 +0,0 @@
-module Symbiont
-  module Enclosers
-    # Provides a context for an action that must succeed within a given time period.
-    # The logic here is simply that the result of the action will be true (meaning
-    # the action was carried out) or false, which means the action did not succeed
-    # in the time allotted.
-    #
-    # @param [Integer] timeout the amount of time in seconds to wait
-    # @param [String] message the text to return if the action did not occur in time
-    # @param [Proc] block the code that calls the desired action
-    #
-    # @example
-    #   @page.wait_for(5, 'page with expected title not found') do
-    #     @page.title.should == "Test App"
-    #   end
-    def wait_for(timeout=Symbiont.page_level_wait, message=nil, &block)
-      platform.wait_for(timeout, message, &block)
-    end
-
-    # Used to identify a web object or action on a web object as existing
-    # within an enclosing window object. The window can be referenced using
-    # either the title attribute of the window or a direct URL. The URL does
-    # not have to be the entire URL; it can just be a page name.
-    #
-    # @param [Hash] locator the :title or :url of the window
-    # @param [Proc; optional] block any code that should be executed as an
-    # action on or within the window
-    #
-    # @example
-    #   page.within_window(title: "Report Page")
-    #   page.within_window(url: report.html)
-    def within_window(locator, &block)
-      platform.within_window(locator, &block)
-    end
-
-    # Used to identify a web object as existing within an enclosing object
-    # like a frame or an iframe. It is possible to nest by passing in parent
-    # enclosers as the second parameter.
-    #
-    # @param [String] locator how an encloser will be referenced; the
-    # only valid locators here are :id, :index, and :name
-    # @param encloser a parent encloser that is passed from a previous call
-    # @param [optional] block that contains calls to web objects within the
-    # encloser
-    #
-    # @example
-    #   within_frame(id: "loginSection") do |encloser|
-    #     text_field :username, id: "userName", frame: encloser
-    #     button :login, id: "btnSubmit", frame: encloser
-    #   end
-    def within_frame(locator, encloser=nil, &block)
-      platform.within_frame(locator, encloser, &block)
-    end
-
-    # Used to identify a web object as existing within an enclosing object
-    # like a modal dialog box. What this does is override the normal call to
-    # showModalDialog and opens a window instead. In order to use this new
-    # window, you have to attach to it.
-    def within_modal(&block)
-      convert_modal_to_window = %Q{
-        window.showModalDialog = function(sURL, vArguments, sFeatures) {
-          window.dialogArguments = vArguments;
-          modalWin = window.open(sURL, 'modal', sFeatures);
-          return modalWin;
-        }
-      }
-      @browser.execute_script(convert_modal_to_window)
-      yield if block_given?
-    end
-
-    # Provides a context for an action that will generate a JavaScript alert
-    # message box. The alert invocation will be overridden by the platform.
-    #
-    # @param [Proc] block the code that generates the alert
-    # @return [String] the message contained in the alert message box
-    #
-    # @example
-    #   response = @page.will_alert do
-    #     @page.submitForm
-    #   end
-    def will_alert(encloser=nil, &block)
-      platform.will_alert(encloser, &block)
-    end
-    
-    # Provides a context for an action that will generate a JavaScript
-    # confirmation message box. The confirmation invocation will be
-    # overridden by the platform.
-    #
-    # @param [bool] response true to accept the confirmation, false to cancel it
-    # @param [Proc] block the code that generates the confirmation
-    # @return [String] the message contained in the confirmation message box
-    #
-    # @example
-    #   response = @page.will_confirm(true) do
-    #     @page.areYouSure
-    #   end
-    def will_confirm(response, encloser=nil, &block)
-      platform.will_confirm(response, encloser, &block)
-    end
-    
-    # Provides a context for an action that will generate a JavaScript prompt
-    # message box. The prompt invocation will be overridden by the platform.
-    #
-    # @param [String] response the value to be used in the prompt
-    # @param [Proc] block the code that generates the prompt
-    # @return [Hash] :message for the prompt message, :default_value for
-    # the value that the prompt had before the response was applied
-    #
-    # @example
-    #   response = @page.will_prompt("use this") do
-    #     @page.useValue
-    #   end
-    def will_prompt(response, encloser=nil, &block)
-      platform.will_prompt(response, encloser, &block)
-    end
-    
-  end # module: Enclosers
-end # module: Symbiont

data/lib/symbiont/evaluators.rb

@@ -1,92 +0,0 @@
-module Symbiont
-  module Evaluators
-
-    ## Browser-Level Actions ##
-
-    def visit(url)
-      platform.visit(url)
-    end
-
-    alias_method :navigate_to, :visit
-
-    def url
-      platform.url
-    end
-
-    alias_method :current_url, :url
-
-    # Save a snapshot of the current screen to a provided file location.
-    # The file will be saved as a PNG file in the path specified or in the
-    # location where the tests are being run from.
-    def screenshot(file)
-      platform.screenshot file
-    end
-
-    alias_method :save_screenshot, :screenshot
-
-    # Executes JavaScript against the browser instance.
-    def run_script(script)
-      platform.run_script(script)
-    end
-
-    alias_method :execute_script, :run_script
-
-    def back
-      platform.back
-    end
-
-    def forward
-      platform.forward
-    end
-
-    def refresh
-      platform.refresh
-    end
-
-    def remove_cookies
-      platform.remove_cookies
-    end
-
-    alias_method :clear_cookies, :remove_cookies
-
-    ## Page-Level Actions ##
-
-    def text
-      platform.text
-    end
-    
-    def markup
-      platform.markup
-    end
-    
-    alias_method :html, :markup
-    
-    def title
-      platform.title
-    end
-
-    # Returns the element on a page that has the focus.
-    def focus
-      platform.focus
-    end
-
-    alias_method :what_has_focus?, :focus
-
-    def wait_for_app(value=1)
-      sleep value
-    end
-
-    # Provides an evaluator that attempts to wait for any pending AJAX
-    # requests from the jQuery library.
-    def wait_for_pending_requests(time_limit=30, message_if_timeout=nil)
-      end_time = ::Time.now + time_limit
-      until ::Time.now > end_time
-        return if @browser.execute_script('return jQuery.active') == 0
-        sleep 0.5
-      end
-      message = "Pending jQuery requests never indicated completion." unless message_if_timeout
-      raise message
-    end
-    
-  end # module: Evaluators
-end # module: Symbiont

data/lib/symbiont/generators.rb

@@ -1,331 +0,0 @@
-module Symbiont
-  module Generators
-
-    def url_is(url)
-      define_method("view") do
-        platform.visit(url)
-      end
-    end
-
-    def begin_at(url)
-      define_method("start") do
-        platform.visit(url)
-      end
-    end
-
-    def title_is(title)
-      define_method('has_title?') do
-        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
-        valid_title
-      end
-    end
-    
-    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
-          raise "\n\nThe '#{widget}' object was not declared and could not be checked."
-        end
-      end
-    end
-
-    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
-        return platform.paragraph_text_for(locator.clone) unless block_given?
-        self.send("#{identifier}_object").text
-      end
-
-      common_definition_methods(identifier, locator, 'paragraph_element', &block)
-    end
-
-    alias_method :p, :paragraph
-
-    def link(identifier, locator={index: 0}, &block)
-      define_method(identifier) do
-        return platform.click_link_for(locator.clone) unless block_given?
-        self.send("#{identifier}_object").click
-      end
-
-      common_definition_methods(identifier, locator, 'link_element', &block)
-    end
-
-    alias_method :a, :link
-
-    def button(identifier, locator={index: 0}, &block)
-      define_method(identifier) do
-        return platform.click_button_for(locator.clone) unless block_given?
-        self.send("#{name}_object").click
-      end
-
-      common_definition_methods(identifier, locator, 'button_element', &block)
-    end
-
-    def text_field(identifier, locator={index: 0}, &block)
-      define_method(identifier) do
-        return platform.get_text_field_value_for(locator.clone) unless block_given?
-        self.send("#{identifier}_object").value
-      end
-
-      define_method("#{identifier}=") do |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', &block)
-    end
-
-    alias_method :textfield, :text_field
-    alias_method :text, :text_field
-
-    def text_area(identifier, locator={index: 0}, &block)
-      define_method(identifier) do
-        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
-        platform.get_select_list_value_for(locator.clone)
-      end
-
-      define_method("#{identifier}_options?") do
-        object = self.send("#{identifier}_object")
-        (object && object.options) ? object.options.collect(&:text) : []
-      end
-
-      define_method("#{identifier}=") do |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', &block)
-    end
-
-    alias_method :select, :select_list
-    
-    def checkbox(identifier, locator={index: 0}, &block)
-      define_method("check_#{identifier}") do
-        return platform.check_checkbox_for(locator.clone) unless block_given?
-        self.send("#{identifier}_object").check
-      end
-      
-      define_method("uncheck_#{identifier}") do
-        return platform.uncheck_checkbox_for(locator.clone) unless block_given?
-        self.send("#{identifier}_object").uncheck
-      end
-      
-      define_method("#{identifier}_checked?") do
-        return platform.check_checkbox_for_checked(locator.clone) unless block_given?
-        self.send("#{identifier}_object").checked?
-      end
-
-      common_definition_methods(identifier, locator, 'checkbox_element', &block)
-    end
-    
-    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
-        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
-        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', &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 div(identifier, locator={index: 0}, &block)
-      define_method(identifier) do
-        return platform.div_text_for(locator.clone) unless block_given?
-        self.send("#{identifier}_object").text
-      end
-
-      common_definition_methods(identifier, locator, 'div_element', &block)
-    end
-    
-    def span(identifier, locator={index: 0}, &block)
-      define_method(identifier) do
-        return platform.span_text_for(locator.clone) unless block_given?
-        self.send("#{identifier}_object").text
-      end
-
-      common_definition_methods(identifier, locator, 'span_element', &block)
-    end
-
-    def h1(identifier, locator={index: 0}, &block)
-      define_method(identifier) do
-        return platform.h1_text_for(locator.clone) unless block_given?
-        self.send("#{identifier}_object").text
-      end
-
-      common_definition_methods(identifier, locator, 'h1_element', &block)
-    end
-
-    def h2(identifier, locator={index: 0}, &block)
-      define_method(identifier) do
-        return platform.h2_text_for(locator.clone) unless block_given?
-        self.send("#{identifier}_object").text
-      end
-
-      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, &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
-
-      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
-      alias_method "#{identifier}_?".to_sym, "#{identifier}_visible?".to_sym
-      alias_method "#{identifier}!".to_sym, "#{identifier}_enabled?".to_sym
-    end
-
-  end # module: Generators
-end # module: Symbiont

data/lib/symbiont/locators.rb

@@ -1,43 +0,0 @@
-module Symbiont
-  module Locators
-    def link_object(locator)
-      platform.link_element(locator)
-    end
-    
-    def button_object(locator)
-      platform.button_element(locator)
-    end
-    
-    def text_field_object(locator)
-      platform.text_field_element(locator)
-    end
-    
-    def select_list_object(locator)
-      platform.select_list_element(locator)
-    end
-    
-    def checkbox_object(locator)
-      platform.checkbox_element(locator)
-    end
-    
-    def radio_object(locator)
-      platform.radio_element(locator)
-    end
-    
-    def div_object(locator)
-      platform.div_element(locator)
-    end
-    
-    def span_object(locator)
-      platform.span_element(locator)
-    end
-    
-    def table_object(locator)
-      platform.table_element(locator)
-    end
-    
-    def cell_object(locator)
-      platform.cell_element(locator)
-    end
-  end # module: Locators
-end # module: Symbiont

data/lib/symbiont/logger.rb

@@ -1,5 +0,0 @@
-module Symbiont
-  def self.trace(message, level=1)
-    puts("*" * level + " #{message}") if ENV['TRACE'] == 'on'
-  end
-end