rwebspec-webdriver 0.1

data/lib/rwebspec/element_locator.rb

@@ -0,0 +1,87 @@
+module RWebSpec
+
+  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

data/lib/rwebspec/load_test_helper.rb

@@ -0,0 +1,172 @@
+
+module RWebSpec
+  module LoadTestHelper
+
+    include RWebSpec::Utils
+    include RWebSpec::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::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

data/lib/rwebspec/matchers/contains_text.rb

@@ -0,0 +1,37 @@
+class ContainsText
+
+  # this is what the matcher is called on.
+  # In this case:
+  #   foo.should contains(:bars)
+  # foo would be passed to the +initialize+
+  def initialize(expected)
+    @expected = expected
+  end
+
+  def matches?(actual)
+    @actual = actual
+    return actual && actual.include?(@expected)
+  end
+
+  def actual_text
+    @actual.to_s.length > 256 ? @actual[0, 255] : @actual
+  end
+
+  # error message for should
+  def failure_message
+    "expected '#{actual_text}' to contain '#{@expected}', but it didn't"
+  end
+
+  # error message for should_not
+  def negative_failure_message
+    "expected '#{actual_text}' not to contain '#{@expected}', but it did"
+  end
+
+end
+
+
+# This method is the one you use with should/should_not
+def contains_text?(expected)
+  ContainsText.new(expected)
+end
+alias contains? contains_text?

data/lib/rwebspec/popup.rb

@@ -0,0 +1,147 @@
+module RWebSpec
+  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

data/lib/rwebspec/rspec_helper.rb

@@ -0,0 +1,99 @@
+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 RSpecHelper
+    include RWebSpec::Driver
+    include RWebSpec::Assert
+    include RWebSpec::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