fluent 0.1.0 → 0.2.0

data/lib/fluent/platform_selenium.rb

@@ -0,0 +1,18 @@
+module Fluent
+  module Platforms
+    module SeleniumWebDriver
+
+      def self.create_platform_object_for(browser)
+        require 'fluent/platform_selenium/platform_object'
+        return SeleniumWebDriver::PlatformObject.new(browser)
+      end
+
+      def self.works_with?(browser)
+        browser.is_a?(::Selenium::WebDriver::Driver)
+      end
+
+    end
+  end
+end
+
+Fluent::Platforms.register(:selenium_webdriver, Fluent::Platforms::SeleniumWebDriver)

data/lib/fluent/platform_selenium/platform_object.rb

@@ -0,0 +1,21 @@
+module Fluent
+  module Platforms
+    module SeleniumWebDriver
+      class PlatformObject
+
+        attr_reader :browser
+        
+        def initialize(browser)
+          @browser = browser
+        end
+
+        ## Browser-Level Actions ##
+
+        def visit(url)
+          browser.navigate.to(url)
+        end
+        
+      end
+    end
+  end
+end

data/lib/fluent/platform_watir/platform_object.rb

@@ -15,6 +15,75 @@ module Fluent
           browser.goto(url)
         end
         
+        def url
+          browser.url
+        end
+
+        def remove_cookies
+          browser.cookies.clear
+        end
+
+        def refresh
+          browser.refresh
+        end
+
+        def run_script(script)
+          browser.execute_script(script)
+        end
+
+        def screenshot(file)
+          browser.wd.save_screenshot(file)
+        end
+        
+        ## Page-Level Actions ##
+
+        def markup
+          browser.html
+        end
+        
+        def title
+          browser.title
+        end
+        
+        def text
+          browser.text
+        end
+
+        def wait_until(timeout, message='wait condition was not found', &block)
+          browser.wait_until(timeout, message, &block)
+        end
+        
+        ## Encloser Actions ##
+        
+        def will_alert(&block)
+          yield
+          value = nil
+          if browser.alert.exists?
+            value = browser.alert.text
+            browser.alert.ok
+          end
+          value
+        end
+        
+        def will_confirm(response, &block)
+          yield
+          value = nil
+          if browser.alert.exists?
+            value = browser.alert.text
+            response ? browser.alert.ok : browser.alert.close
+          end
+          value
+        end
+        
+        def will_prompt(response, &block)
+          cmd = "window.prompt = function(text, value) {window.__lastWatirPrompt = {message: text, default_value: value}; return #{!!response};}"
+          browser.wd.execute_script(cmd)
+          yield
+          result = browser.wd.execute_script('return window.__lastWatirPrompt')
+          result && result.dup.each_key { |k| result[k.to_sym] = result.delete(k) }
+          result
+        end
+        
         ## Generator Actions ##
         
         def link(locator)
@@ -22,7 +91,7 @@ module Fluent
         end
         
         def link_click(locator)
-          browser.instance_eval('link(locator).click')
+          access_web_element('link(locator).click', locator)
         end
         
         def button(locator)
@@ -30,7 +99,7 @@ module Fluent
         end
         
         def button_click(locator)
-          browser.instance_eval('button(locator).click')
+          access_web_element('button(locator).click', locator)
         end
         
         def text_field(locator)
@@ -38,11 +107,23 @@ module Fluent
         end
         
         def text_field_set(locator, value)
-          browser.instance_eval('text_field(locator).set(value)')
+          access_web_element('text_field(locator).set(value)', locator, value)
         end
         
         def text_field_get(locator)
-          browser.instance_eval('text_field(locator).value')
+          access_web_element('text_field(locator).value', locator)
+        end
+
+        def text_area(locator)
+          reference_web_element('text_area(locator)', WebElements::TextArea, locator)
+        end
+        
+        def text_area_set(locator, value)
+          access_web_element('text_area(locator).set(value)', locator, value)
+        end
+        
+        def text_area_get(locator)
+          access_web_element('text_area(locator).value', locator)
         end
         
         def checkbox(locator)
@@ -50,15 +131,15 @@ module Fluent
         end
         
         def checkbox_check_state(locator)
-          browser.instance_eval('checkbox(locator).set?')
+          access_web_element('checkbox(locator).set?', locator)
         end
         
         def checkbox_check(locator)
-          browser.instance_eval('checkbox(locator).set')
+          access_web_element('checkbox(locator).set', locator)
         end
         
         def checkbox_uncheck(locator)
-          browser.instance_eval('checkbox(locator).clear')
+          access_web_element('checkbox(locator).clear', locator)
         end
         
         def select_list(locator)
@@ -66,15 +147,15 @@ module Fluent
         end
         
         def select_list_get_selected(locator)
-          browser.instance_eval('select_list(locator).selected_options[0].text')
+          access_web_element('select_list(locator).selected_options[0].text', locator)
         end
         
         def select_list_set(locator, value)
-          browser.instance_eval('select_list(locator).select(value)')
+          access_web_element('select_list(locator).select(value)', locator, value)
         end
         
         def select_list_get_value(locator)
-          browser.instance_eval('select_list(locator).value')
+          access_web_element('select_list(locator).value', locator)
         end
         
         def radio(locator)
@@ -82,11 +163,11 @@ module Fluent
         end
         
         def radio_select(locator)
-          browser.instance_eval('radio(locator).set')
+          access_web_element('radio(locator).set', locator)
         end
         
         def radio_check_state(locator)
-          browser.instance_eval('radio(locator).set?')
+          access_web_element('radio(locator).set?', locator)
         end
         
         def paragraph(locator)
@@ -94,13 +175,99 @@ module Fluent
         end
         
         def paragraph_text(locator)
-          browser.instance_eval('p(locator).text')
+          access_web_element('p(locator).text', locator)
+        end
+
+        def div(locator)
+          reference_web_element('div(locator)', WebElements::Div, locator)
+        end
+
+        def div_text(locator)
+          access_web_element('div(locator).text', locator)
+        end
+
+        def span(locator)
+          reference_web_element('span(locator)', WebElements::Span, locator)
+        end
+
+        def span_text(locator)
+          access_web_element('span(locator).text', locator)
+        end
+        
+        def ordered_list(locator)
+          reference_web_element('ol(locator)', WebElements::OrderedList, locator)
+        end
+        
+        def ordered_list_text(locator)
+          access_web_element('ol(locator).text', locator)
+        end
+
+        def unordered_list(locator)
+          reference_web_element('ul(locator)', WebElements::UnorderedList, locator)
+        end
+
+        def unordered_list_text(locator)
+          access_web_element('ul(locator).text', locator)
+        end
+
+        def list_item(locator)
+          reference_web_element('li(locator)', WebElements::ListItem, locator)
+        end
+
+        def list_item_text(locator)
+          access_web_element('li(locator).text', locator)
+        end
+
+        def table(locator)
+          reference_web_element('table(locator)', WebElements::Table, locator)
+        end
+
+        def table_text(locator)
+          access_web_element('table(locator).text', locator)
+        end
+
+        def cell(locator)
+          reference_web_element('td(locator)', WebElements::Cell, locator)
+        end
+
+        def cell_text(locator)
+          access_web_element('td(locator).text', locator)
         end
         
+        # This method is called by any platform methods that require getting
+        # an object reference.
+        #
+        # @param action [String] the driver logic to be sent to the browser
+        # @param object [Object] the type of web object that will receive the action
+        # @param locator [Hash] the specific web object selector
+        # @return [Object] the web object identified by the action
         def reference_web_element(action, object, locator)
-          element_object = browser.instance_eval(action)
+          encloser = locator.delete(:frame)
+          element_object = browser.instance_eval("#{enclosed_by(encloser)}#{action}")
           object.new(element_object, :platform => :watir_webdriver)
         end
+
+        # This method is called by any platform methods that require accessing
+        # a web object with the intent of manipulating it or getting information
+        # from it.
+        #
+        # @param action [String] the driver logic to be sent to the browser
+        # @param locator [Hash] the specific web object selector
+        # @param value [String] any specific information that must be sent to the web object
+        # @return [Any] the information or object returned by the action
+        def access_web_element(action, locator, value=nil)
+          encloser = locator.delete(:frame)
+          browser.instance_eval("#{enclosed_by(encloser)}#{action}")
+        end
+        
+        def enclosed_by(encloser)
+          return if encloser.nil?
+
+          key = encloser[0].keys.first
+          value = encloser[0].values.first
+          
+          "frame(:#{key} => '#{value}')."
+        end
         
       end
     end

data/lib/fluent/platform_watir/platform_web_elements/checkbox.rb

@@ -0,0 +1,21 @@
+module Fluent
+  module Platforms
+    module WatirWebDriver
+      module CheckBox
+        
+        def checked?
+          web_element.set?
+        end
+        
+        def check
+          web_element.set
+        end
+        
+        def uncheck
+          web_element.clear
+        end
+        
+      end
+    end
+  end
+end

data/lib/fluent/platform_watir/platform_web_elements/radio.rb

@@ -0,0 +1,21 @@
+module Fluent
+  module Platforms
+    module WatirWebDriver
+      module Radio
+
+        def selected?
+          web_element.set?
+        end
+
+        def select
+          web_element.set
+        end
+
+        def clear
+          web_element.clear
+        end
+        
+      end
+    end
+  end
+end

data/lib/fluent/platform_watir/platform_web_elements/select_list.rb

@@ -3,6 +3,36 @@ module Fluent
     module WatirWebDriver
       module SelectList
         
+        def select(value)
+          web_element.select(value)
+        end
+
+        def select_value(value)
+          web_element.select_value(value)
+        end
+
+        def selected?(value)
+          web_element.selected? value
+        end
+        
+        # @return [Array] array of strings representing the text of the currently selected options
+        def selected_options
+          web_element.selected_options.map { |e| e.text }.compact
+        end
+
+        # @return [Array] array of strings representing the value of the currently selected options
+        def selected_values
+          web_element.selected_options.map { |e| e.value }.compact
+        end
+
+        def include?(value)
+          web_element.include? value
+        end
+        
+        # Returns an object representing the option for the index provided.
+        # The index is zero-based.
+        #
+        # @return [Object] Fluent::WebElements::Option
         def [](index)
           ::Fluent::WebElements::Option.new(options[index], :platform => :watir_webdriver)
         end
@@ -20,10 +50,6 @@ module Fluent
           elements
         end
         
-        def option_xpath
-          './/child::option'
-        end
-        
       end
     end
   end

data/lib/fluent/platform_watir/platform_web_elements/text_field.rb

@@ -0,0 +1,13 @@
+module Fluent
+  module Platforms
+    module WatirWebDriver
+      module TextField
+        
+        def value=(text)
+          web_element.set(text)
+        end
+        
+      end
+    end
+  end
+end

data/lib/fluent/platform_watir/platform_web_elements/web_element.rb

@@ -2,11 +2,7 @@ module Fluent
   module Platforms
     module WatirWebDriver
       module WebElement
-
-        def text
-          web_element.text
-        end
-
+        
         def exists?
           web_element.exists?
         end
@@ -15,6 +11,89 @@ module Fluent
           web_element.present?
         end
         
+        def double_click
+          web_element.double_click
+        end
+        
+        def clear
+          web_element.clear
+        end
+        
+        def flash(value=5)
+          1.upto(value) { web_element.flash }
+          web_element.exists?
+        end
+
+        def tag_name
+          web_element.tag_name
+        end
+
+        def html
+          web_element.html
+        end
+        
+        def attribute(name)
+          web_element.attribute_value(name)
+        end
+
+        def fire_event(event)
+          web_element.fire_event(event)
+        end
+
+        def value
+          web_element.value
+        end
+        
+        def id
+          web_element.id
+        end
+
+        def send_keys(*args)
+          web_element.send_keys(*args)
+        end
+
+        def scroll_into_view
+          web_element.wd.location_once_scrolled_into_view
+        end
+        
+        def focus
+          web_element.focus
+        end
+
+        def hover
+          web_element.hover
+        end
+
+        def when_present(timeout=::Fluent.element_level_wait)
+          web_element.wait_until_present(timeout)
+          self
+        end
+        
+        def when_not_present(timeout=::Fluent.element_level_wait)
+          web_element.wait_while_present(timeout)
+          self
+        end
+
+        def when_visible(timeout=::Fluent.element_level_wait)
+          Object::Watir::Wait.until(timeout, "Object not visible within #{timeout} seconds.") do
+            visible?
+          end
+          self
+        end
+
+        def when_not_visible(timeout=::Fluent.element_level_wait)
+          Object::Watir::Wait.while(timeout, "Object still visible after #{timeout} seconds.") do
+            visible?
+          end
+          self
+        end
+
+        def wait_until(timeout=::Fluent.element_level_wait, message=nil, &block)
+          Object::Watir::Wait.until(timeout, message, &block)
+        end
+        
+        alias_method :when_actionable, :when_present
+        alias_method :when_not_actionable, :when_not_present
       end
     end
   end