mk_firewatir 1.6.5

data/lib/firewatir/jssh_socket.rb

@@ -0,0 +1,101 @@
+module JsshSocket
+  # Evaluate javascript and return result. Raise an exception if an error occurred.
+  def js_eval(str)
+    str.gsub!("\n", "")
+    jssh_socket.send("#{str};\n", 0)
+    value = read_socket()
+    if md = /^(\w+)Error:(.*)$/.match(value)
+      errclassname="JS#{md[1]}Error"
+      unless JsshSocket.const_defined?(errclassname)
+        JsshSocket.const_set(errclassname, Class.new(StandardError))
+      end
+      raise JsshSocket.const_get(errclassname), md[2]
+    end
+    value
+  end
+
+  # evaluate the provides javascript method on the current object and return
+  # the result
+  def js_eval_method method_name
+    js_eval("#{element_object}.#{method_name}")
+  end
+
+  def jssh_socket
+    $jssh_socket || @container.jssh_socket
+  end
+
+  #
+  # Description:
+  #  Reads the javascript execution result from the jssh socket.
+  #
+  # Input:
+  # 	- socket - It is the jssh socket, the  only point of communication between the browser and firewatir scripts.
+  #
+  # Output:
+  #	The javascript execution result as string.
+  #
+  def read_socket(socket = jssh_socket)
+    return_value = ""
+    data = ""
+    receive = true
+    #puts Thread.list
+    s = nil
+    while(s == nil) do
+      s = Kernel.select([socket] , nil , nil, 1)
+    end
+    #if(s != nil)
+    for stream in s[0]
+      data = stream.recv(1024)
+      #puts "data is : #{data}"
+      while(receive)
+        #while(data.length == 1024)
+        return_value += data
+        if(return_value.include?("\n> "))
+          receive = false
+        else
+          data = stream.recv(1024)
+        end
+        #puts "return_value is : #{return_value}"
+        #puts "data length is : #{data.length}"
+      end
+    end
+
+    # If received data is less than 1024 characters or for last data
+    # we read in the above loop
+    #return_value += data
+
+    # Get the command prompt inserted by JSSH
+    #s = Kernel.select([socket] , nil , nil, 0.3)
+
+    #if(s != nil)
+    #    for stream in s[0]
+    #        return_value += socket.recv(1024)
+    #    end
+    #end
+
+    length = return_value.length
+    #puts "Return value before removing command prompt is : #{return_value}"
+
+    #Remove the command prompt. Every result returned by JSSH has "\n> " at the end.
+    if length <= 3
+      return_value = ""
+    elsif(return_value[0..2] == "\n> ")
+      return_value = return_value[3..length-1]
+    else
+      #return_value = return_value[0..length-3]
+      return_value = return_value[0..length-4]
+    end
+    #puts "Return value after removing command prompt is : #{return_value}"
+    #socket.flush
+
+    # make sure that command prompt doesn't get there.
+    if(return_value[return_value.length - 3..return_value.length - 1] == "\n> ")
+      return_value = return_value[0..return_value.length - 4]
+    end
+    if(return_value[0..2] == "\n> ")
+      return_value = return_value[3..return_value.length - 1]
+    end
+    #puts "return value is : #{return_value}"
+    return return_value
+  end
+end

data/lib/firewatir/version.rb

@@ -0,0 +1,5 @@
+module FireWatir
+  class Firefox
+    VERSION = '1.6.5'
+  end
+end

data/lib/firewatir/winClicker.rb

@@ -0,0 +1,122 @@
+if /linux/i.match(RUBY_PLATFORM)
+	require File.expand_path(File.join(File.dirname(__FILE__), 'x11'))
+
+	# Linux/X11 implementation of WinClicker.
+	# Not all functionality is present because of the differences between X11
+	#   and Win32.
+	class WinClicker
+
+		def clickJavaScriptDialog(button="OK")
+			click_window_button(/The page/,button)
+		end
+
+		def clickJSDialog_Thread(button="OK")
+			puts "clickJSDialog_Thread Starting waiting..."
+			sleep 3
+			puts " clickJSDialog_Thread ... resuming"
+			n = 0
+			while n < 3
+				sleep 1
+				click_window_button(/The page/,button)
+			end
+		end
+
+		def clearSecurityAlertBox
+			click_window_button(/Unknown Authority/, "OK")
+			click_window_button(/Domain Name Mismatch/, "Cancel")
+		end
+
+		def clickWindowsButton(title, button, maxWaitTime=30)
+			start = Time.now
+			w = window_by_title(title)
+			until w || (Time.now - start > maxWaitTime)
+				sleep(2) # Window search is pretty CPU intensive, so relax the requirement
+				w = window_by_title(title)
+			end
+			unless w
+				puts "clickWindowsButton: Cant make window active in specified time ( " + maxWaitTime.to_s + ") - no handle"
+				return false
+			end
+			click_button(w,button)
+		end
+
+	private
+
+		# Since it's impossible to read the button text in X11 windows,
+		#   we have to specify keystrokes for the button names given the title.
+		# TODO: A more elegant solution, or expand this list (to fill out popup text boxes for basic HTTP auth, perhaps).
+		@@window_keys = [
+			[/Unknown Authority/i, {'ok' => [:enter], 'cancel' => [:tab,:tab,:tab,:enter]}],
+			[/Domain Name Mismatch/i, {'ok' => [:tab, :enter], 'cancel' => [:enter]}],
+			[/Opening/i, {'ok' => [:sleep,:enter], 'cancel' => [:tab,:tab,:tab,:enter]}],
+			[/The page at .* says/i, {'ok' => [:enter], 'cancel' => [:tab,:enter]}]
+		]
+
+		# Collection of all current firefox windows
+		def firefox_windows(w = nil)
+			collection = []
+			windows = nil
+			if w
+				windows = [w]
+			else
+				windows = X11::Display.instance.screens.collect{|s| s.root_window}
+			end
+			windows.each do |window|
+				if window.class == 'Gecko'
+					collection << window
+				end
+				window.children.each do |c|
+					collection << firefox_windows(c)
+				end
+			end
+			return collection.flatten.compact
+		end
+
+		def window_by_title(title,windows=nil)
+			pattern = nil
+			if title.is_a?(Regexp)
+				pattern = title
+			else
+				pattern = Regexp.compile(title,Regexp::IGNORECASE)
+			end
+			windows ||= X11::Display.instance.screens.collect{|s| s.root_window}
+			if window = windows.find{|w| w.class == 'Gecko' && pattern.match(w.name)}
+				return window
+			else
+				children = windows.reject{|w| w.class == 'Gecko'}.collect{|w| w.children}.flatten.compact
+				if children.length > 0
+					return window_by_title(pattern,children)
+				end
+			end
+			return nil
+		end
+
+		def keystrokes(window,button) 
+			keys = @@window_keys.find{|wk| wk.first.match(window.name)}
+			if keys
+				return keys.last[button.downcase]
+			else
+				return false
+			end
+		end
+
+		def click_button(window, button)
+			keys = nil
+			if button.is_a?(Symbol)
+				keys = [button]
+			else
+				keys = keystrokes(window,button)
+			end
+			return unless keys
+			keys.each do |key|
+				if key == :sleep
+					@sleep_next = 1
+					next
+				end
+				window.send_key(key,@sleep_next)
+				@sleep_next = nil
+			end
+		end
+
+	end
+end

data/lib/firewatir/x11.rb

@@ -0,0 +1,192 @@
+require 'dl/import'
+require 'dl/struct'
+
+require 'singleton'
+
+module X11
+	class << self
+		include X11 # Do this so we can call imported libraries directly on X11
+	end
+
+	# Load the X11 library
+	extend DL::Importable
+	dlload "libX11.so" 
+	
+	# Import necessary functions from X11 here.
+	import("XOpenDisplay", "unsigned long", ["char*"])
+	import("XScreenCount", "int", ["unsigned long"])
+	import("XRootWindow", "unsigned long", ["unsigned long","int"])
+
+	import("XFree", "int", ["void*"])
+
+	import("XFetchName", "int", ["unsigned long","unsigned long","char**"])
+	import("XGetClassHint", "int", ["unsigned long","unsigned long","void*"])
+	import("XQueryTree", "int", ["unsigned long","unsigned long","unsigned long*","unsigned long*","unsigned long**","unsigned int*"])
+
+	import("XSetInputFocus", "int", ["unsigned long","unsigned long","int","long"])
+	import("XSendEvent", "int", ["unsigned long","unsigned long","int","long","void*"])
+	import("XFlush", "int", ["unsigned long"])
+
+	# Structs we will use in API calls.
+	# Pointer structs are necessary when the API uses a pointer parameter for a return value.
+	ULPPointer = struct [
+		"long* value"
+	]
+	ULPointer = struct [
+		"long value"
+	]
+	CPPointer = struct [
+		"char* value"
+	]
+	UIPointer = struct [
+		"int value"
+	]
+	# Info about window class
+	XClassHint = struct [
+		"char* res_name",
+		"char* res_class"
+	]
+	# Event struct for key presses
+	XKeyEvent = struct [
+		"int type",
+		"long serial",
+		"int send_event",
+		"long display",
+		"long window",
+		"long root",
+		"long subwindow",
+		"long time",
+		"int x",
+		"int y",
+		"int x_root",
+		"int y_root",
+		"int state",
+		"int keycode",
+		"int same_screen"
+	]
+
+	# End of library imports.
+
+	# X11 Display. Singleton -- assumes single display.
+	# Assumes the current display is the same as the one running FireFox.
+	# Represented by memory pointer (which we treat in-code as an unsigned long).
+	class Display
+		include Singleton
+
+		def initialize
+			@xdisplay = X11.xOpenDisplay("");
+		end
+
+		# Array of screens associated with this display.
+		def screens
+			nScreens = X11.xScreenCount(@xdisplay);
+			(0...nScreens).collect{|n| Screen.new(n,@xdisplay)}
+		end
+	end
+
+	# A display screen, for multi-monitor displays like mine ;-)
+	# Represented by display pointer and screen number.
+	class Screen
+		def initialize(screen_num,xdisplay)
+			@screen_num = screen_num
+			@xdisplay = xdisplay
+		end
+
+		# Root window containing all other windows in this screen.
+		def root_window
+			Window.new(X11.xRootWindow(@xdisplay,@screen_num),@screen_num,@xdisplay)
+		end
+	end
+
+	# An X11 Window (toplevel window, widget, applet, etc.)
+	# Represented by its XID, an unsigned long.
+	class Window
+		attr_reader :xid, :name, :class, :hint, :parent
+
+		def initialize(xid,screen_num,xdisplay,parent=nil)
+			@xid = xid
+			@screen_num = screen_num
+			@xdisplay = xdisplay
+			@parent = parent
+			load_standard
+		end
+
+		# Child windows
+		def children
+			tree[:children].collect{|c| Window.new(c,@screen_num,@xdisplay,self)}
+		end
+
+		# XID of parent window
+		def parent_xid
+			parent ? parent.xid : nil
+		end
+
+		# Send a key press to this window
+		def send_key(key=:enter,sleep=nil)
+			# TODO expand this list out, add support for shift, etc.
+			@@keys = {:enter => 36, :tab => 23} unless defined?@@keys
+			keycode = @@keys[key]
+			X11.xSetInputFocus(@xdisplay, @xid, 1, 0)
+			sleep(sleep) if sleep
+			e = create_key_event
+			e.keycode = keycode
+			e.type = 2 # press
+			X11.xSendEvent(@xdisplay,@xid,1,1,e)
+			e.type = 3 # release
+			X11.xSendEvent(@xdisplay,@xid,1,2,e)
+			X11.xFlush(@xdisplay)
+		end
+
+		private
+
+		# Retrieve this window's portion of the window tree
+		# Includes display root, parent, and children
+		def tree
+			tree = {:children => [], :parent => 0, :root => 0}
+			children = ULPPointer.malloc
+			root = ULPointer.malloc
+			parent = ULPointer.malloc
+			n = UIPointer.malloc
+			r=X11.xQueryTree(@xdisplay,@xid,root,parent,children,n)
+			tree[:parent] = parent.value
+			tree[:root] = root.value
+			tree[:children] = children.value.to_s(4*n.value).unpack("L*") if children.value
+			tree
+		end
+
+		# Load some standard attributes (name and class)
+		def load_standard
+			name = CPPointer.malloc
+			if X11.xFetchName(@xdisplay,@xid,name) != 0
+				@name = name.value.to_s
+				X11.xFree name.value
+			end
+			classHint = XClassHint.malloc
+			res = X11.xGetClassHint(@xdisplay,@xid,classHint)
+			if res != 0 then
+				@class = classHint.res_name.to_s
+				@hint = classHint.res_class.to_s
+				X11.xFree classHint.res_name
+				X11.xFree classHint.res_class
+			end
+		end
+
+		# Create an X11 Key Event for this window and set defaults
+		def create_key_event
+			ke = XKeyEvent.malloc
+			ke.serial = 0
+			ke.send_event = 1
+			ke.display = @xdisplay
+			ke.window = @xid
+			ke.subwindow = 0
+			ke.root = tree[:root]
+			ke.time = Time.now.sec
+			ke.state = 0
+			ke.same_screen = 0
+			return ke
+		end
+
+	end
+
+end
+

data/unittests/attach_to_new_window_test.rb

@@ -0,0 +1,49 @@
+# feature tests for attaching to new Firefox windows
+# revision: $Revision: 1.0 $
+
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..') unless $SETUP_LOADED
+require 'unittests/setup'
+
+class TC_NewWindow < Test::Unit::TestCase
+    tags :fails_on_ie
+
+    def setup
+      goto_page("new_browser.html")
+    end
+
+    def test_simply_attach_to_new_window_using_title
+        browser.link(:text, 'New Window').click
+        begin 
+          ff_new = browser.attach(:title, 'Pass Page')
+        rescue Watir::Exception::NoMatchingWindowFoundException
+          raise $!, "Attach failed, check your Firefox settings: http://wiki.openqa.org/display/WTR/FireWatir+Installation#FireWatirInstallation-ffsettings" 
+        end
+        assert(ff_new.text.include?('PASS'))
+        ff_new.close
+        #browser.link(:text, 'New Window').click
+    end
+    
+    def test_simply_attach_to_new_window_using_url
+        browser.link(:text, 'New Window').click
+        begin
+          ff_new = browser.attach(:url, /pass\.html/)
+        rescue Watir::Exception::NoMatchingWindowFoundException
+          raise $!, "Attach failed, check your Firefox settings: http://wiki.openqa.org/display/WTR/FireWatir+Installation#FireWatirInstallation-ffsettings" 
+        end
+        assert(ff_new.text.include?('PASS'))
+        ff_new.close
+        #browser.link(:text, 'New Window').click
+    end
+
+    def test_attach_to_new_window_with_same_title_as_parent
+        browser.link(:text, 'New Browser Window').click
+        ff_new = browser.attach(:title, 'New Browser Launcher')
+        assert(ff_new.text.include?('PASS'))
+        ff_new.close
+    end
+     
+    def test_new_window_exists
+        assert_raises(NoMatchingWindowFoundException , "NoMatchingWindowFoundException was supposed to be thrown" ) {   browser.attach(:title, "missing_title")   }  
+        assert_raises(NoMatchingWindowFoundException , "NoMatchingWindowFoundException was supposed to be thrown" ) {   browser.attach(:url, "missing_url")   }  
+    end
+end