rwebspec-webdriver 0.1.1 → 0.1.2

data/lib/rwebspec-webdriver/element_locator.rb

@@ -0,0 +1,89 @@
+module RWebSpec
+  module WebDriver
+
+    module ElementLocator
+
+      BUTTON_VALID_TYPES = %w[button reset submit image]
+      def button_elements
+        find_elements(:xpath, ".//button | .//input[#{attribute_expression :type => BUTTON_VALID_TYPES}]")
+      end
+
+      CHECK_BOX_TYPES = %w(checkbox)
+      def check_box_elements(how, what, opts = [])
+        find_elements(:xpath, ".//input[#{attribute_expression :type => CHECK_BOX_TYPES}]")
+      end
+
+      RADIO_TYPES = %w(radio)
+      def radio_elements(how, what, opts = [])
+        find_elements(:xpath, ".//input[#{attribute_expression :type => RADIO_TYPES}]")
+      end
+
+      def select_elements(how, what, opts = [])
+        find_elements(:xpath, ".//input[#{attribute_expression :type => RADIO_TYPES}]")
+      end
+
+      # TextField, TextArea
+      TEXT_FILED_TYPES = %w(text)
+      def text_field_elements
+        find_elements(:xpath, ".//input[#{attribute_expression :type => TEXT_FILED_TYPES}]")
+      end
+
+      def text_area_elements
+        find_elements(:xpath, ".//textarea")
+      end
+
+      FILE_FIELD_TYPES = %w(file)
+      def file_field_elements
+        find_elements(:xpath, ".//input[#{attribute_expression :type => FILE_FIELD_TYPES}]")
+      end
+
+      HIDDEN_TYPES = %w(hidden)
+      def hidden_elements
+        find_elements(:xpath, ".//input[#{attribute_expression :type => HIDDEN_TYPES}]")
+      end
+
+      #---
+      def find_by_tag(tag)
+        find_elements(:tag_name, tag)
+      end
+
+      def should_use_label_element?
+        @selector[:tag_name] != "option" rescue false
+      end
+
+      def equal_pair(key, value)
+        # we assume :label means a corresponding label element, not the attribute
+        if key == :label && should_use_label_element?
+          "@id=//label[normalize-space()='#{value}']/@for"
+        else
+          "#{lhs_for(key)}='#{value}'"
+        end
+      end
+
+      def lhs_for(key)
+        case key
+        when :text, 'text'
+          'normalize-space()'
+        when :href
+          # TODO: change this behaviour?
+          'normalize-space(@href)'
+        else
+          "@#{key.to_s.gsub("_", "-")}"
+        end
+      end
+
+
+      def attribute_expression(selectors)
+        selectors.map do |key, val|
+          if val.kind_of?(Array)
+            "(" + val.map { |v| equal_pair(key, v) }.join(" or ") + ")"
+          else
+            equal_pair(key, val)
+          end
+        end.join(" and ")
+      end
+
+    end
+
+  end
+end

data/lib/rwebspec-webdriver/load_test_helper.rb

@@ -0,0 +1,174 @@
+
+module RWebSpec
+  module WebDriver
+    module LoadTestHelper
+
+      include RWebSpec::WebDriver::Utils
+      include RWebSpec::WebDriver::Assert
+
+      MAX_VU = 1000
+
+      # only support firefox or Celerity
+      def open_browser(base_url, options = {})
+        default_options = {:resynchronize => false, :firefox => false }
+        options = default_options.merge(options)
+        options[:firefox] ||= (ENV['LOADWISE_PREVIEW'] || $LOADWISE_PREVIEW)
+        RWebSpec::WebDriver::WebBrowser.new(base_url, nil, options)
+      end
+
+      # maybe attach_browser
+
+      # Does not provide real function, other than make enhancing test syntax
+      #
+      # Example:
+      #   allow { click_button('Register') }
+      def allow(&block)
+        yield
+      end
+      alias shall_allow  allow
+      alias allowing  allow
+
+      # try operation, ignore if errors occur
+      #
+      # Example:
+      #   failsafe { click_link("Logout") }  # try logout, but it still OK if not being able to (already logout))
+      def failsafe(&block)
+        begin
+          yield
+        rescue =>e
+        end
+      end
+      alias fail_safe failsafe
+
+      # Try the operation up to specified timeout (in seconds), and sleep given interval (in seconds).
+      # Error will be ignored until timeout
+      # Example
+      #    try { click_link('waiting')}
+      #    try(10, 2) { click_button('Search' } # try to click the 'Search' button upto 10 seconds, try every 2 seconds
+      #    try { click_button('Search' }
+      def try(timeout = @@default_timeout, polling_interval = @@default_polling_interval || 1, &block)
+        start_time = Time.now
+
+        last_error = nil
+        until (duration = Time.now - start_time) > timeout
+          begin
+            return if yield
+            last_error = nil
+          rescue => e
+            last_error = e
+          end
+          sleep polling_interval
+        end
+
+        raise "Timeout after #{duration.to_i} seconds with error: #{last_error}." if last_error
+        raise "Timeout after #{duration.to_i} seconds."
+      end
+      alias try_upto try
+
+      ##
+      #  Convert :first to 1, :second to 2, and so on...
+      def symbol_to_sequence(symb)
+        value = { :zero => 0,
+          :first => 1,
+          :second => 2,
+          :third => 3,
+          :fourth => 4,
+          :fifth => 5,
+          :sixth => 6,
+          :seventh => 7,
+          :eighth => 8,
+          :ninth => 9,
+        :tenth => 10 }[symb]
+        return value || symb.to_i
+      end
+
+      # monitor current execution using
+      #
+      # Usage
+      #  log_time { browser.click_button('Confirm') }
+      def log_time(msg, &block)
+        start_time = Time.now
+        yield
+        end_time = Time.now
+
+        Thread.current[:log] ||= []
+        Thread.current[:log] << {:file => File.basename(__FILE__),
+          :message => msg,
+          :start_time => Time.now,
+        :duration => Time.now - start_time}
+
+        if $LOADWISE_MONITOR
+          begin
+            require 'java'
+            puts "Calling Java 1"
+            java_import com.loadwise.db.MemoryDatabase
+            #puts "Calling Java 2: #{MemoryDatabase.count}"
+            MemoryDatabase.addEntry(1, "zdfa01", "a_spec.rb", msg, start_time, end_time);
+            puts "Calling Java Ok: #{MemoryDatabase.count}"
+          rescue NameError => ne
+            puts "Name Error: #{ne}"
+            # failed to load Java class
+          rescue => e
+            puts "Failed to calling Java: #{e.class.name}"
+          end
+        end
+        # How to notify LoadWise at real time
+        # LoadWise to collect CPU
+      end
+
+      def run_with_virtual_users(virtual_user_count = 2, preview = false, &block)
+        raise "too many virtual users" if virtual_user_count > MAX_VU
+
+        begin
+          if defined?(LOADWISE_PREVIEW)
+            preview = LOADWISE_PREVIEW
+          end
+        rescue => e1
+        end
+
+        if preview
+          virtual_user_count = 1
+          $LOADWISE_PREVIEW = true
+        end
+
+        if (virtual_user_count <= 1)
+          yield
+        else
+          threads = []
+          vu_reports = {}
+          virtual_user_count.times do |idx|
+            threads[idx] = Thread.new do
+              start_time = Time.now
+              vu_reports[idx] ||= []
+              begin
+                yield
+                vu_reports[idx] =  Thread.current[:log]
+              rescue => e
+                vu_reports[idx] =  Thread.current[:log]
+                vu_reports[idx] ||= []
+                vu_reports[idx] << { :error => e }
+              end
+              vu_reports[idx] ||= []
+              vu_reports[idx] << { :message => "Total Duration", :duration => Time.now - start_time }
+              puts "VU[#{idx+1}] #{Time.now - start_time}s"
+            end
+          end
+
+          threads.each {|t| t.join; }
+          vu_reports.each do |key, value|
+            value.each do |entry|
+              if entry[:error] then
+                puts "Error: #{entry[:error]}"
+              else
+                puts "[#{key}] #{entry[:message]}, #{entry[:duration]}"
+              end
+            end
+          end
+
+          return vu_reports
+        end
+      end
+
+    end
+  end
+end

data/lib/rwebspec-webdriver/popup.rb

@@ -0,0 +1,149 @@
+module RWebSpec
+  module WebDriver
+    module Popup
+
+      #= Popup
+      #
+
+      # Start background thread to click popup windows
+      #  Warning:
+      #    Make browser window active
+      #    Don't mouse your mouse to focus other window during test execution
+      def check_for_popups
+        autoit = WIN32OLE.new('AutoItX3.Control')
+        #
+        # Do forever - assumes popups could occur anywhere/anytime in your
+        # application.
+        loop do
+          # Look for window with given title. Give up after 1 second.
+          ret = autoit.WinWait('Windows Internet Explorer', '', 1)
+          #
+          # If window found, send appropriate keystroke (e.g. {enter}, {Y}, {N}).
+          if (ret==1) then
+            autoit.Send('{enter}')
+          end
+          #
+          # Take a rest to avoid chewing up cycles and give another thread a go.
+          # Then resume the loop.
+          sleep(3)
+        end
+      end
+
+      ##
+      #  Check for "Security Information" and "Security Alert" alert popup, click 'Yes'
+      #
+      # Usage: For individual test suite
+      #
+      # before(:all) do
+      #  $popup = Thread.new { check_for_alerts }
+      #  open_in_browser
+      #  ...
+      # end
+      #
+      # after(:all) do
+      #   close_browser
+      #   Thread.kill($popup)
+      # end
+      #
+      # or for all tests,
+      #  $popup = Thread.new { check_for_alerts }
+      #  at_exit{ Thread.kill($popup) }
+      def check_for_security_alerts
+        autoit = WIN32OLE.new('AutoItX3.Control')
+        loop do
+          ["Security Alert", "Security Information"].each do |win_title|
+            ret = autoit.WinWait(win_title, '', 1)
+            if (ret==1) then
+              autoit.Send('{Y}')
+            end
+          end
+          sleep(3)
+        end
+      end
+
+      def verify_alert(title = "Microsoft Internet Explorer", button = "OK")
+        if is_windows? && !is_firefox?
+          WIN32OLE.new('AutoItX3.Control').ControlClick(title, '', button)
+        else
+          raise "This function only supports IE"
+        end
+      end
+
+      def click_button_in_security_information_popup(button = "&Yes")
+        verify_alert("Security Information", "", button)
+      end
+      alias click_security_information_popup click_button_in_security_information_popup
+
+      def click_button_in_security_alert_popup(button = "&Yes")
+        verify_alert("Security Alert", "", button)
+      end
+      alias click_security_alert_popup click_button_in_security_alert_popup
+
+      def click_button_in_javascript_popup(button = "OK")
+        verify_alert()
+      end
+      alias click_javascript_popup click_button_in_javascript_popup
+
+      ##
+      # This only works for IEs
+      #   Cons:
+      #     - Slow
+      #     - only works in IE
+      #     - does not work for security alert ?
+      def ie_popup_clicker(button_name = "OK", max_wait = 15)
+        require 'watir/contrib/enabled_popup'
+        require 'win32ole'
+        hwnd = ie.enabled_popup(15)
+        if (hwnd)  #yeah! a popup
+          popup = WinClicker.new
+          popup.makeWindowActive(hwnd) #Activate the window.
+          popup.clickWindowsButton_hwnd(hwnd, button_name) #Click the button
+          #popup.clickWindowsButton(/Internet/,button_name,30)
+          popup = nil
+        end
+      end
+
+      def click_popup_window(button, wait_time= 9, user_input=nil )
+        @web_browser.start_clicker(button, wait_time, user_input)
+        sleep 0.5
+      end
+      # run a separate process waiting for the popup window to click
+      #
+      #
+      def prepare_to_click_button_in_popup(button = "OK", wait_time = 3)
+        #  !@web_browser.is_firefox?
+        # TODO: firefox is OK
+        if RUBY_PLATFORM =~ /mswin/ ||  RUBY_PLATFORM =~ /mingw/ then
+          start_checking_js_dialog(button, wait_time)
+        else
+          raise "this only support on Windows and on IE"
+        end
+      end
+
+      # Start a background process to click the button on a javascript popup window
+      def start_checking_js_dialog(button = "OK", wait_time = 3)
+        w = WinClicker.new
+        longName = File.expand_path(File.dirname(__FILE__)).gsub("/", "\\" )
+        shortName = w.getShortFileName(longName)
+        c = "start ruby #{shortName}\\clickJSDialog.rb #{button} #{wait_time} "
+        w.winsystem(c)
+        w = nil
+      end
+
+      # Click the button in javascript popup dialog
+      # Usage:
+      #   click_button_in_popup_after { click_link('Cancel')}
+      #   click_button_in_popup_after("OK") { click_link('Cancel')}
+      #
+      def click_button_in_popup_after(options = {:button => "OK", :wait_time => 3}, &block)
+        if is_windows?  then
+          start_checking_js_dialog(options[:button], options[:wait_time])
+          yield
+        else
+          raise "this only support on Windows and on IE"
+        end
+      end
+
+    end
+  end
+end

data/lib/rwebspec-webdriver/rspec_helper.rb

@@ -0,0 +1,101 @@
+require 'uri'
+require File.dirname(__FILE__) + "/driver"
+require File.dirname(__FILE__) + "/web_page"
+require File.dirname(__FILE__) + "/assert"
+
+# ZZ patches to RSpec 1.1.2 - 1.1.4
+#  - add to_s method to example_group
+module Spec
+  module Example
+    class ExampleGroup
+      def to_s
+        @_defined_description
+      end
+    end
+  end
+end
+
+# example
+#   should link_by_text(text, options).size > 0
+
+module RWebSpec
+  module WebDriver
+    module RSpecHelper
+      include RWebSpec::WebDriver::Driver
+      include RWebSpec::WebDriver::Assert
+      include RWebSpec::WebDriver::Utils
+
+      # --
+      #  Content
+      # --
+
+      def table_source(table_id)
+        table(:id, table_id).innerHTML
+        # elem = @web_browser.document.getElementById(table_id)
+        # raise "The element '#{table_id}' is not a table or there are multple elements with same id" unless elem.name.uppercase == "TABLE"
+        # elem.innerHTML
+      end
+      alias table_source_by_id table_source
+
+      def element_text(elem_id)
+        @web_browser.element_value(elem_id)
+      end
+      alias element_text_by_id element_text
+
+      #TODO: is it working?
+      def element_source(elem_id)
+        @web_browser.get_html_in_element(elem_id)
+      end
+
+
+      def button_by_id(button_id)
+        button(:id, button_id)
+      end
+
+      def buttons_by_caption(text)
+        button(:text, text)
+      end
+      alias buttons_by_text buttons_by_caption
+
+      def link_by_id(link_id)
+        link(:id, link_id)
+      end
+
+      # default options: exact => true
+      def links_by_text(link_text, options = {})
+        options.merge!({:exact=> true})
+        matching_links = []
+        links.each { |link|
+          matching_links << link if (options[:exact] ? link.text == link_text :  link.text.include?(link_text))
+        }
+        return matching_links
+      end
+      alias links_with_text links_by_text
+
+      def save_page(file_name = nil)
+        @web_browser.save_page(file_name)
+      end
+
+      def save_content_to_file(content, file_name = nil)
+        file_name ||= Time.now.strftime("%Y%m%d%H%M%S") + ".html"
+        puts "about to save page: #{File.expand_path(file_name)}"
+        File.open(file_name, "w").puts content
+      end
+
+      # When running
+      def debugging?
+        $ITEST2_DEBUGGING && $ITEST2_RUNNING_AS == "test_case"
+      end
+
+      # RSpec Matchers
+      #
+      # Example,
+      #   a_number.should be_odd_number
+      def be_odd_number
+        simple_matcher("must be odd number") { |actual| actual && actual.to_id % 2 == 1}
+      end
+
+    end
+
+  end
+end