rwebspec-mechanize 0.2.1

data/lib/rwebspec-mechanize/extensions/rspec_extensions.rb

@@ -0,0 +1,51 @@
+module Spec
+  module Extensions
+    module Main
+
+      alias :spec :describe
+      alias :specification :describe
+      alias :test_suite :describe
+      alias :suite :describe
+
+    end
+  end
+end
+
+# For RSpec 1.1.12
+module Spec
+  module DSL
+    module Main
+
+      alias :spec :describe
+      alias :specification :describe
+      alias :test_suite :describe
+      alias :suite :describe
+
+    end
+  end
+end
+
+# ZZ patches to RSpec 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
+
+module Spec
+  module Example
+    module ExampleGroupMethods
+
+      alias_method :scenario, :it
+      alias_method :story, :it
+      alias_method :test_case, :it
+      alias_method :use_case, :it
+      alias_method :test, :it
+    end
+  end
+end

data/lib/rwebspec-mechanize/extensions/watir_extensions.rb

@@ -0,0 +1,85 @@
+gem 'watir'
+require 'fileutils'
+require 'watir/container'
+require 'watir/element_collections'
+require 'watir/element'
+
+module Watir
+  # Base class for html elements.
+  # This is not a class that users would normally access.
+  class Element
+
+    def method_missing(method_name, *args, &block)
+
+      if ($TESTWISE_DIR || $TESTWISE_BROWSER) &&  method_name.to_s =~ /(.*)_no_wait/ && self.respond_to?($1)
+        ruby_code = testwise_generate_ruby_code(self, $1, *args)
+        testwise_click_no_wait(ruby_code)
+
+      elsif method_name.to_s =~ /(.*)_no_wait/ && self.respond_to?($1)
+        puts "[Watir] handle it"
+        assert_exists
+        assert_enabled
+        highlight(:set)
+        ruby_code = generate_ruby_code(self, $1, *args)
+        system(spawned_no_wait_command(ruby_code))
+        highlight(:clear)
+      else
+        super
+      end
+
+    end
+
+
+    def testwise_generate_ruby_code(element, method_name, *args)
+      element = "#{self.class}.new(#{@page_container.attach_command}, :unique_number, #{self.unique_number})"
+      method = build_method(method_name, *args)
+      watir_load_path = []
+      watir_lib_path = nil
+      $LOAD_PATH.each do |x|
+        if x =~ /rautomation/ || x =~ /watir/
+          watir_load_path << x
+          if x =~ /\/gems\/watir-/
+            watir_lib_path = x
+          end
+        end
+      end
+      watir_load_path = $LOAD_PATH
+      ruby_code = "$:.unshift(#{watir_load_path.map {|p| "'#{p}'" }.join(").unshift(")});" <<
+      "require '#{watir_lib_path}/watir/core';#{element}.#{method};"
+      return ruby_code
+    end
+
+    # customiiation here
+    #
+    def testwise_click_no_wait(ruby_code)
+      begin
+        puts "[TestWise] I am handling it"
+        assert_exists
+        assert_enabled
+        highlight(:set)
+        current_path = File.expand_path(".")
+
+        # not necessary
+        # ruby_code.gsub("C:/Program Files/TestWise/vendor/bundle/ruby/1.8", "C:/rubyshell/ruby/lib/ruby/gems/1.8")
+
+        # Trick 1: need to set RUBYOPT, otherwise might get -F error    
+        ENV["RUBYOPT"] = "-rubygems"
+        
+        # Trick 2: need to wrap no-wait click operation in a thread
+        Thread.new do
+	        # this will pop up Windows Command window
+          # system("ruby", "-e", ruby_code)
+          system("rubyw", "-e", ruby_code)
+        end
+        highlight(:clear)
+      rescue RuntimeError => re
+        puts re.backtrace
+
+      rescue => e
+        puts "Failed to click_no_wait: #{e.backtrace}"
+        raise e
+      end
+    end
+
+  end
+end

data/lib/rwebspec-mechanize/extensions/window_script_extensions.rb

@@ -0,0 +1,19 @@
+require 'rubygems'
+require 'watir'
+
+# Used for calling javacript of VBScript
+# Applies to IE only
+#
+# Ref: http://msdn.microsoft.com/en-us/library/aa741364%28VS.85%29.aspx
+#
+module Watir
+  class IE
+    def execute_script(scriptCode)
+      window.execScript(scriptCode)
+    end
+
+    def window
+      ie.Document.parentWindow
+    end
+  end
+end

data/lib/rwebspec-mechanize/load_test_helper.rb

@@ -0,0 +1,359 @@
+require File.join(File.dirname(__FILE__), "plugins", "loadwise_plugin.rb")
+require "timeout"
+
+module RWebSpec
+  module Mechanize
+    
+    module LoadTestHelper
+
+      include RWebSpec::Mechanize::Utils
+      include RWebSpec::Mechanize::Assert
+      include RWebSpec::Mechanize::LoadWisePlugin
+
+      MAX_VU = 1000
+    
+      # only support firefox or Celerity
+      def open_browser(base_url = nil, options = {})
+        default_options = {:resynchronize => false, :firefox => false, :go => false }      
+        options = default_options.merge(options)
+      
+        base_url ||= $LOADWISE_PROJECT_BASE_URL        
+				if RUBY_PLATFORM =~ /java/
+        	base_url ||= ENV["LOADWISE_PROJECT_BASE_URL"] # pass to java
+				end
+        base_url ||= $BASE_URL
+        puts "[DEBUG] open |#{base_url}|#{$BASE_URL}| in browser"
+
+        mode_preview = ($LOADWISE_PREVIEW || ENV['LOADWISE_PREVIEW'])
+        
+        unless mode_preview
+          RWebSpec::Mechanize::WebBrowser.new(base_url, nil, options)
+        else
+          if RUBY_PLATFORM =~ /mingw/
+            puts "loading RWEBSPEC..."
+            require 'rwebspec'
+						RWebSpec.framework = "Watir"
+            RWebSpec::WebBrowser.new(base_url, nil, options)          
+          else 
+            require 'rwebspec'         
+						RWebSpec.framework = "Selenium-WebDriver"
+						if RUBY_PLATFORM =~ /darwin/ 
+						  if File.exists?("/usr/bin/chromedriver") && File.exists?("/usr/local/bin/chromedriver") 						    
+							  options[:browser] = "chrome" 
+						  else
+							  options[:browser] = "firefox" 
+					    end
+					  else
+					    options[:browser] = "firefox"
+						end
+            RWebSpec::WebBrowser.new(base_url, nil, options)
+          end
+        end
+      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_for { click_link('waiting')}
+      #    try_for(10, 2) { click_button('Search' } # try to click the 'Search' button upto 10 seconds, try every 2 seconds
+      #    try_for { click_button('Search' }
+      def try_for(timeout = $testwise_polling_timeout, polling_interval = $testwise_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_for
+      alias try_until try_for
+
+      ##
+      #  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
+        begin; 
+					dump_caller_stack; 
+				rescue; 
+				end;
+
+        Thread.current[:log] ||= []
+        begin
+ 					yield
+
+	        Thread.current[:log] << {:file => File.basename(__FILE__),
+	          :message => msg,
+	          :start_time => Time.now,
+	          :duration => Time.now - start_time}
+
+				rescue => e
+
+	        Thread.current[:log] << {:file => File.basename(__FILE__),
+	          :message => msg + " => Failed",
+	          :start_time => Time.now,
+	          :duration => Time.now - start_time}
+				ensure
+					end_time = Time.now	        
+					format_date_time = start_time.strftime("%Y-%m-%d %H:%M:%S")
+					connect_to_loadwise("  LOAD", "#{Thread.current[:id]}|#{msg}|#{format_date_time}|#{Time.now - start_time}")
+				end
+      
+      end
+  
+      def init_memory_database(force = true)
+        # Open a database
+        require 'sqlite3'
+        if $memory_db.nil? || force
+          $memory_db = SQLite3::Database.new ":memory:"
+        
+
+          # Create a database
+          rows = $memory_db.execute "
+            create table load_test_stats (
+              id integer PRIMARY KEY,
+              virtual_user varchar(64),
+              test_file varchar(256),
+              description varchar(256),          
+              started_at integer,
+              duration decimal(6, 2),
+              ended_at integer
+            );"
+        end
+
+      end
+
+			# 
+			# @started_at : Unix timestamp to get back: Time.at()
+			# 
+      def append_test_result(vu, test_file, description, started_at, duration)
+        return if RUBY_PLATFORM =~ /java/
+        init_memory_database if $memory_db.nil?
+				begin
+        $memory_db.execute("insert into load_test_stats (virtual_user, test_file, description, started_at, duration, ended_at) values (?, ?, ?, ?, ?, ?)", vu, "", description, started_at, duration, Time.now.to_i)
+				rescue => e
+					puts "[WARN] Failed to append test results: #{vu}|#{test_file}|#{description}|#{started_at}|#{duration}\n#{e} => #{e.backtrace}"
+				end
+				
+      end
+
+      ##
+      #
+      #  How many virtual users should be running immedately
+      #  :start_virtual_user_count  
+      # 
+      #  How many threads should be running at peak load.
+      #  :peak_virtual_user_count  
+      #
+      # How many seconds to wait between starting threads.
+      #  :delay_between_thread_start
+      #
+      #
+      # How many minutes the test should run with all threads active.
+      # TIME_AT_PEAK_QPS = 10 # minutes
+      # 
+      # Defaults:
+      # :start_virtual_user_count => 1, :peak_virtual_user_count => 3, :delay_between_thread_start => 10
+      def run_with_virtual_users(opts = {}, &block)
+        
+        init_memory_database unless RUBY_PLATFORM =~ /java/
+        $vu_error_printed = false
+
+        if $load_runtime_options          
+          default_opts = $load_runtime_options
+				else				
+	        if RUBY_PLATFORM =~ /java/
+	          default_opts = {}
+	          default_opts[:start_virtual_user_count] = ENV["LOADWISE_START_VIRTUAL_USER_COUNT"].to_i if  ENV["LOADWISE_START_VIRTUAL_USER_COUNT"]
+	          default_opts[:peak_virtual_user_count] = ENV["LOADWISE_PEAK_VIRTUAL_USER_COUNT"].to_i if  ENV["LOADWISE_PEAK_VIRTUAL_USER_COUNT"]
+	          default_opts[:delay_between_thread_start] = ENV["LOADWISE_DELAY_BETWEEN_THREAD_START"].to_i if  ENV["LOADWISE_DELAY_BETWEEN_THREAD_START"]     
+	          default_opts[:for_how_long] = ENV["LOADWISE_FOR_HOW_LONG"].to_i if  ENV["LOADWISE_FOR_HOW_LONG"]
+        	else
+						# default to performance testing
+            default_opts = {:start_virtual_user_count => 1, 
+                          :peak_virtual_user_count => 1, 
+                          :delay_between_thread_start => 0 }
+          end
+        end
+
+        opts = default_opts.merge(opts)
+        puts "[INFO] {LoadTestHelper} opts => #{opts.inspect}"
+        start_virtual_user_count = opts[:start_virtual_user_count] || 2
+        peak_virtual_user_count  = opts[:peak_virtual_user_count]  || 2
+        delay_between_thread_start  =  opts[:delay_between_thread_start] || 0
+        for_how_long = opts[:for_how_long]
+        
+        # puts "DEBUG for_how_long => #{for_how_long}"
+        if opts[:virtual_user_count] then
+          start_virtual_user_count ||= opts[:virtual_user_count]
+          peak_virtual_user_count ||= opts[:virtual_user_count]
+        end
+        
+        raise "too many virtual users" if peak_virtual_user_count > MAX_VU
+            
+        if $LOADWISE_PREVIEW 
+          start_virtual_user_count = peak_virtual_user_count = 1          
+        end
+      
+        connect_to_loadwise("VU_START", "")
+
+        if (peak_virtual_user_count <= 1)
+          yield
+        else
+          threads = []
+          vu_reports = {}
+                
+          start_virtual_user_count.times do |idx|          
+            threads[idx] = Thread.new do
+							Thread.current[:id] = idx
+              start_time = Time.now
+              vu_reports[idx] ||= []
+              begin
+                if for_how_long 
+                  Timeout::timeout(for_how_long) do 
+                    while(true)
+                      yield
+                    end    
+                  end            
+                else
+                  yield                  
+                end
+                
+                vu_reports[idx] =  Thread.current[:log]
+              rescue Timeout::Error
+                vu_reports[idx] =  Thread.current[:log]
+                puts "Too Slow 2"                   
+              rescue => e
+                vu_reports[idx] =  Thread.current[:log]
+                vu_reports[idx] ||= []
+                vu_reports[idx] << { :error => e }
+								# TODO
+								connect_to_loadwise("VU_ERROR", Thread.current[:id].to_s + "|" + e.to_s)	              
+								unless $vu_error_printed
+									puts "VU[#{idx}] Failed: " +  e.backtrace.to_s
+									$vu_error_printed = true
+								end
+							
+              end
+              vu_reports[idx] ||= []
+              vu_reports[idx] << { :message => "Total Duration (Initial)", :start_time => start_time, :duration => Time.now - start_time }     
+              connect_to_loadwise("VU_END", Thread.current[:id].to_s)
+              puts "VU[#{idx+1}] #{Time.now - start_time}s"
+            end
+          end
+
+          (peak_virtual_user_count - start_virtual_user_count).times do |nidx|
+            sleep delay_between_thread_start
+            idx = nidx + start_virtual_user_count
+            threads[idx] = Thread.new do
+              start_time = Time.now
+              vu_reports[idx] ||= []
+              begin
+                if for_how_long 
+                  Timeout::timeout(for_how_long) do 
+                    while(true)
+                      yield
+                    end    
+                  end            
+                else
+                  yield                  
+                end
+                vu_reports[idx] =  Thread.current[:log]
+              rescue Timeout::Error
+                vu_reports[idx] =  Thread.current[:log]
+                puts "!!!Too Slow 2"                                   
+              rescue => e
+                vu_reports[idx] =  Thread.current[:log]
+                vu_reports[idx] ||= []
+                vu_reports[idx] << { :error => e }
+								connect_to_loadwise("VU_ERROR", Thread.current[:id].to_s + "|" + e.to_s)	              								
+								unless $vu_error_printed
+									puts "VU[#{idx}] Failed: " +  e.backtrace.to_s
+									$vu_error_printed = true
+								end
+              end
+              vu_reports[idx] ||= []
+              vu_reports[idx] << { :message => "Total Duration (Peak)", :start_time => start_time,  :duration => Time.now - start_time }            
+              puts "VU[#{idx+1}] #{Time.now - start_time}s"
+            end          
+          end
+          
+          threads.each {|t| t.join; }
+        
+=begin
+# after test finishing, don't try to parse the data, LoadWise can see $memory database
+
+          vu_reports.each do |key, value|
+            value.each do |entry|
+              append_test_result(key.to_s, entry[:file], entry[:message], entry[:start_time].to_i, entry[:duration])
+              if entry[:error] then
+                puts "{load_test_helper.rb} Execution Error: #{entry[:error]}"
+	              append_test_result(key.to_s, entry[:file], entry[:error], entry[:start_time].to_i, entry[:duration])
+              else
+                puts "[#{key}] #{entry[:message]}, #{entry[:duration]}"
+              end
+            end
+          end
+=end
+          return vu_reports
+
+
+        end
+      end      
+
+  end  
+
+
+  end
+end

data/lib/rwebspec-mechanize/plugins/loadwise_plugin.rb

@@ -0,0 +1,93 @@
+require 'socket'
+
+module RWebSpec
+  module Mechanize
+  
+  module LoadWisePlugin
+
+    def debug(message)
+      Thread.pass
+      connect_to_loadwise(" DEBUG", message.to_s + "\r\n") if $RUN_IN_TESTWISE && message
+    end
+
+		def connect_to_loadwise(message_type, body)
+			return if RUBY_PLATFORM !~ /java/i && $LOADWISE_TRACE_PORT.nil?
+			# Thread.pass      
+			loadwise_port = ($LOADWISE_TRACE_PORT || 7125) + rand(5)
+	    the_message = message_type + "|" + body
+			
+		  begin
+		    # $log.info("[MESSAGE] " + the_message)
+		    loadwise_socket = Socket.new(Socket::AF_INET, Socket::SOCK_STREAM, 0)
+		    loadwise_socket.connect(Socket.pack_sockaddr_in(loadwise_port, '127.0.0.1'))
+		    loadwise_socket.puts(the_message)
+		    @last_message = the_message
+		    loadwise_socket.close
+		  rescue => e
+		    puts("Failed to contact LoadWise '#{message_type}|#{body}' at #{loadwise_port}: #{e}")
+				retry
+		    # $log.warn("Failed to contact TestWise: #{e}")
+		  end
+		end
+		
+    # Support of iTest to ajust the intervals between keystroke/mouse operations
+    def operation_delay
+      begin
+    		
+				if $TESTWISE_OPERATION_DELAY && $TESTWISE_OPERATION_DELAY > 0 &&
+                $TESTWISE_OPERATION_DELAY < 30000  then # max 30 seconds
+          Thread.pass
+          sleep($TESTWISE_OPERATION_DELAY / 1000)
+        end
+
+        while $TESTWISE_PAUSE || $LOADWISE_PAUSE
+          Thread.pass
+          debug("Paused, waiting ...")
+          sleep 1
+        end
+      rescue => e
+        puts "Error on delaying: #{e}"
+        # ignore
+      end
+    end
+
+    def notify_screenshot_location(image_file_path)
+      connect_to_loadwise("  SHOT", image_file_path)
+    end
+
+    # find out the line (and file) the execution is on, and notify iTest via Socket
+    def dump_caller_stack
+      # puts "CAlling dump_caller_stack"
+      return unless ($TESTWISE_TRACE_EXECUTION || $LOADWISE_TRACE_EXECUTION)
+      begin
+        trace_lines = []
+        trace_file = nil
+        found_first_spec_reference = false
+        caller.each_with_index do |position, idx|
+          next unless position =~ /\A(.*?):(\d+)/
+          trace_file = $1
+          if trace_file =~ /(_spec|_test|_rwebspec)\.rb\s*$/ || trace_file =~ /\.feature$/
+            found_first_spec_reference = true
+            trace_lines << position
+            break
+          end
+          trace_lines << position
+          break if trace_file =~ /example\/example_methods\.rb$/ or trace_file =~ /example\/example_group_methods\.rb$/
+          break if trace_lines.size > 10
+          # TODO: send multiple trace to be parse with pages.rb
+          # break if trace_file =~ /example\/example_methods\.rb$/ or trace_file =~ /example\/example_group_methods\.rb$/ or trace_file =~ /driver\.rb$/ or trace_file =~ /timeout\.rb$/ # don't include rspec or ruby trace
+        end
+
+        #  (trace_file.include?("_spec.rb") || trace_file.include?("_rwebspec.rb") || trace_file.include?("_test.rb") || trace_file.include?("_cmd.rb"))
+        if !trace_lines.empty?
+          connect_to_loadwise(" TRACE", trace_lines.reverse.join("|"))
+        end
+
+      rescue => e
+        puts "failed to capture log: #{e}"
+      end
+    end
+
+  end
+end
+end

data/lib/rwebspec-mechanize/rspec_helper.rb

@@ -0,0 +1,96 @@
+require 'uri'
+
+# 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::Utils
+    include RWebSpec::Assert
+
+    # --
+    #  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?
+      ($TESTWISE_DEBUGGING && $TESTWISE_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