symbiont 0.1.7 → 0.1.8

data/lib/symbiont/platform_selenium.rb

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

data/lib/symbiont/platform_selenium/platform_object.rb

@@ -0,0 +1,236 @@
+module Symbiont
+  module Platforms
+    module SeleniumWebDriver
+
+      class PlatformObject
+        def initialize(browser)
+          @browser = browser
+        end
+
+        ## Browser-Level Actions ##
+
+        def visit(url)
+          @browser.navigate.to(url)
+        end
+
+        def url
+          @browser.current_url
+        end
+
+        def screenshot(file)
+          @browser.save_screenshot(file)
+        end
+
+        def run_script(script)
+          @browser.execute_script(script)
+        end
+
+        def back
+          @browser.navigate.back
+        end
+
+        ## Page-Level Actions ##
+
+        def text
+          @browser.find_element(:tag_name, 'body').text
+        end
+
+        def markup
+          @browser.page_source
+        end
+
+        def title
+          @browser.title
+        end
+
+        def focus
+          web_object = @browser.execute_script("return document.activeElement")
+          type = web_object.attribute(:type).to_s.downcase 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, :platform => :selenium_webdriver)
+        end
+
+        ## Encloser Methods ##
+
+        # Platform method to wait for an action to complete in a given time.
+        # @see Symbiont::Enclosers#wait_for
+        def wait_for(timeout, message="wait condition not found", &block)
+          wait = ::Selenium::WebDriver::Wait.new({:timeout => timeout, :message => message})
+          wait.until &block
+        end
+
+        ## Generator Methods ##
+
+        ## Paragraphs **
+
+        def paragraph_element(locator)
+          reference_web_object(locator, WebObjects::Paragraph, 'p')
+        end
+
+        def paragraph_text_for(locator)
+          access_web_object(locator, WebObjects::Paragraph, 'p') do |how, what|
+            @browser.find_element(how, what).text
+          end
+        end
+
+        ## Links ##
+
+        def link_element(locator)
+          reference_web_object(locator, WebObjects::Link, 'a')
+        end
+
+        def click_link_for(locator)
+          access_web_object(locator, WebObjects::Link, 'a') do |how, what|
+            @browser.find_element(how, what).click
+          end
+        end
+
+        ## Buttons ##
+
+        def button_element(locator)
+          reference_web_object(locator, WebObjects::Button, 'input', :type => 'submit')
+        end
+
+        def click_button_for(locator)
+          access_web_object(locator, WebObjects::Button, 'input', :type => 'submit') do |how, what|
+            @browser.find_element(how, what).click
+          end
+        end
+
+        ## Text Fields ##
+
+        def text_field_element(locator)
+          reference_web_object(locator, WebObjects::TextField, 'input', :type => 'text')
+        end
+
+        def get_text_field_value_for(locator)
+          access_web_object(locator, WebObjects::TextField, 'input', :type => 'text') do |how, what|
+            @browser.find_element(how, what).attribute('value')
+          end
+        end
+
+        def set_text_field_value_for(locator, value)
+          access_web_object(locator, WebObjects::TextField, 'input', :type => 'text') do |how, what|
+            @browser.find_element(how, what).clear
+            @browser.find_element(how, what).send_keys(value)
+          end
+        end
+
+        ## Checkboxes ##
+
+        def checkbox_element(locator)
+          reference_web_object(locator, WebObjects::CheckBox, 'input', :type => 'checkbox')
+        end
+
+        def check_checkbox_for_checked(locator)
+          access_web_object(locator, WebObjects::CheckBox, 'input', :type => 'checkbox') do |how, what|
+            @browser.find_element(how, what).selected?
+          end
+        end
+
+        def check_checkbox_for(locator)
+          access_web_object(locator, WebObjects::CheckBox, 'input', :type => 'checkbox') do |how, what|
+            @browser.find_element(how, what).click unless @browser.find_element(how, what).selected?
+          end
+        end
+
+        def uncheck_checkbox_for(locator)
+          access_web_object(locator, WebObjects::CheckBox, 'input', :type => 'checkbox') do |how, what|
+            @browser.find_element(how, what).click if @browser.find_element(how, what).selected?
+          end
+        end
+
+        ## Select Lists ##
+
+        def select_list_element(locator)
+          reference_web_object(locator, WebObjects::SelectList, 'select')
+        end
+
+        def get_select_list_item_for(locator)
+          access_web_object(locator, WebObjects::SelectList, 'select') do |how, what|
+            selected = nil
+            @browser.find_element(how, what).find_elements(:tag_name => 'option').each do |o|
+              if selected.nil?
+                selected = o.text if o.selected?
+              end
+            end
+            selected
+          end
+        end
+
+        def get_select_list_value_for(locator)
+          access_web_object(locator, WebObjects::SelectList, 'select') do |how, what|
+            @browser.find_element(how, what).attribute('value')
+          end
+        end
+
+        def set_select_list_value_for(locator, value)
+          access_web_object(locator, WebObjects::SelectList, 'select') do |how, what|
+            select_list = @browser.find_element(how, what)
+            select_list.find_elements(:tag_name => 'option').find do |option|
+              option.text == value
+            end.click
+          end
+        end
+
+        ## Radios ##
+
+        def radio_element(locator)
+          reference_web_object(locator, WebObjects::Radio, 'input', :type => 'radio')
+        end
+
+        def check_radio_for_selected(locator)
+          access_web_object(locator, WebObjects::Radio, 'input', :type => 'radio') do |how, what|
+            @browser.find_element(how, what).selected?
+          end
+        end
+
+        def select_radio_for(locator)
+          access_web_object(locator, WebObjects::Radio, 'input', :type => 'radio') do |how, what|
+            @browser.find_element(how, what).click unless @browser.find_element(how, what).selected?
+          end
+        end
+
+        def div_element(locator)
+          reference_web_object(locator, WebObjects::Div, 'div')
+        end
+
+        def span_element(locator)
+          reference_web_object(locator, WebObjects::Span, 'span')
+        end
+
+        private
+
+        def reference_web_object(locator, object_type, object_tag, type=nil)
+          enclosers = locator.delete(:frame)
+          enter_encloser_context_for(enclosers)
+          how, what = object_type.provide_selenium_locator_for(locator)
+          web_object = @browser.find_element(how, what)
+          object_type.new(web_object, :platform => :selenium_webdriver)
+        end
+
+        def access_web_object(locator, object_type, object_tag, type=nil)
+          enclosers = locator.delete(:frame)
+          enter_encloser_context_for(enclosers)
+          how, what = object_type.provide_selenium_locator_for(locator)
+          value = yield how, what
+          @browser.switch_to.default_content unless enclosers.nil?
+          value
+        end
+
+        def enter_encloser_context_for(enclosers)
+          unless enclosers.nil?
+            enclosers.each do |encloser|
+              value = encloser.values.first
+              @browser.switch_to.frame(value)
+            end
+          end
+        end
+      end # class: PlatformObject
+
+    end # module: SeleniumWebDriver
+  end # module: Platforms
+end # module: Symbiont
+
+require 'symbiont/web_objects'
+Dir["#{File.dirname(__FILE__)}/../web_objects/**/*.rb"].sort.each { |file| require file }

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

@@ -0,0 +1,13 @@
+module Symbiont
+  module Platforms
+    module SeleniumWebDriver
+      module Button
+
+        def text
+          raise "Currently Selenium is not very good at grabbing text from a button."
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+module Symbiont
+  module Platforms
+    module SeleniumWebDriver
+      module CheckBox
+
+        def check
+          web_object.click unless web_object.selected?
+        end
+
+        def uncheck
+          web_object.click if web_object.selected?
+        end
+
+        def checked?
+          web_object.selected?
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,104 @@
+module Symbiont
+  module Platforms
+    module SeleniumWebDriver
+      module WebObject
+
+        def visible?
+          web_object.displayed?
+        end
+
+        def exists?
+          not web_object.nil?
+        end
+
+        def id
+          web_object.attribute(:id)
+        end
+
+        def value
+          web_object.attribute('value')
+        end
+
+        def tag
+          web_object.tag_name
+        end
+
+        def flash
+          original_color = attribute('backgroundColor')
+          bridge = driver_bridge
+          10.times do |n|
+            color = (n % 2 == 0) ? 'red' : original_color
+            bridge.executeScript("arguments[0].style.backgroundColor = '#{color}'", web_object)
+          end
+        end
+
+        def attribute(name)
+          web_object.attribute(name)
+        end
+
+        def focus
+          driver_bridge.executeScript("return arguments[0].focus()", web_object)
+        end
+
+        def wait_until(timeout=::Symbiont.element_level_wait, message=nil, &block)
+          wait = Object::Selenium::WebDriver::Wait.new({:timeout => timeout, :message => message})
+          wait.until &block
+        end
+
+        def when_actionable(timeout=::Symbiont.element_level_wait)
+          wait = Object::Selenium::WebDriver::Wait.new({:timeout => timeout, :message => "Object not present in #{timeout} seconds"})
+          wait.until do
+            self.exists?
+          end
+          self
+        end
+
+        alias_method :when_present, :when_actionable
+
+        def when_not_actionable(timeout=::Symbiont.element_level_wait)
+          wait = Object::Selenium::WebDriver::Wait.new({:timeout => timeout, :message => "Object still present in #{timeout} seconds"})
+          wait.until do
+            not_present = false
+            begin
+              not_present = false if web_object and web_object.displayed?
+            rescue Selenium::WebDriver::Error::ObsoleteElementError
+              not_present = true
+            end
+            not_present
+          end
+        end
+
+        alias_method :when_not_present, :when_not_actionable
+
+        def when_visible(timeout=::Symbiont.element_level_wait)
+          wait = Object::Selenium::WebDriver::Wait.new({:timeout => timeout, :message => "Object not visible in #{timeout} seconds"})
+          wait.until do
+            self.visible?
+          end
+          self
+        end
+
+        def when_not_visible(timeout=::Symbiont.element_level_wait)
+          wait = Object::Selenium::WebDriver::Wait.new({:timeout => timeout, :message => "Object still visible in #{timeout} seconds"})
+          wait.until do
+            not self.visible?
+          end
+          self
+        end
+
+        alias_method :must_be_visible, :when_visible
+        alias_method :must_not_be_visible, :when_not_visible
+
+        def scroll_into_view(wait=2)
+          sleep wait
+          web_object.location_once_scrolled_into_view
+        end
+
+        def driver_bridge
+          bridge = web_object.instance_variable_get(:@bridge)
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+module Symbiont
+  module Platforms
+    module SeleniumWebDriver
+      module Link
+
+        def value
+          raise "Currently Selenium is not very good at grabbing the value from a link."
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+module Symbiont
+  module Platforms
+    module SeleniumWebDriver
+      module Radio
+
+        def select
+          web_object.click unless selected?
+        end
+
+        def clear
+          web_object.click if selected?
+        end
+
+        def selected?
+          web_object.selected?
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,79 @@
+module Symbiont
+  module Platforms
+    module SeleniumWebDriver
+      module SelectList
+
+        # This method is used to return an Option object based on the index provided.
+        # @return [Symbiont::WebObjects::Option]
+        def [](idx)
+          options[idx]
+          #::Symbiont::WebObjects::Option.new(options[idx], :platform => :watir_webdriver)
+        end
+
+        # Selects an option from the select list.
+        def select(value)
+          find_options.find do |option|
+            option.text == value
+          end.click
+        end
+
+        # Selects the option whose value attribute matches the provided string.
+        def select_value(value)
+          options = find_options.find_all do |option|
+            option.attribute('value') == value
+          end
+          options.each {|opt| opt.click}
+        end
+
+        # This method returns an array of Option objects that are contained within
+        # a select list object.
+        # @return [array of Symbiont::WebObjects::Option]
+        def options
+          find_options.map { |e| ::Symbiont::WebObjects::Option.new(e, :platform => :selenium_webdriver) }
+        end
+
+        # This method returns an array of strings that contain the text of the
+        # currently selected options in a select list.
+        # @return [Array<String>]
+        def selected_options
+          find_options.map { |e| e.text if e.selected? }.compact
+        end
+
+        # This method returns an array of strings that contain the values of the
+        # currently selected options in a select list.
+        # @return [Array<String>]
+        def selected_values
+          find_options.map { |e| e.attribute('value') if e.selected? }.compact
+        end
+
+        # This method returns true if any of the text or the lable of any option
+        # that is selected matches the provided value.
+        # @param [String, Regexp] value A value to check for
+        # @return [Boolean]
+        def selected?(value)
+          selected = find_options.select { |e| e if e.selected? }
+          selected.any? { |e| e.text == value }
+        end
+
+        # This method checks to see if the select list has one or more options
+        # where the text or the label matches the provided value.
+        # @param [String, Regexp] value A value to check for.
+        # @return [Boolean]
+        def include?(value)
+          find_options.any? { |e| e.text == value }
+        end
+
+        def clear
+          find_options.select { |e| e.selected? }.each { |o| o.click }
+        end
+
+        private
+
+        def find_options
+          web_object.find_elements(:xpath, option_xpath)
+        end
+
+      end
+    end
+  end
+end