selenium-client 1.1 → 1.2

data/lib/nautilus/shell.rb

@@ -0,0 +1,32 @@
+module Nautilus
+  
+  class Shell
+    
+    def run(command, options = {})
+      sh build_command(command, options)
+    end
+
+    def build_command(command, options = {})
+      actual_command = command.kind_of?(Array) ? command.join(" ") : command
+      if options[:background]
+        if windows?
+          actual_command = "start /wait /b " + command
+        elsif options[:background]
+          actual_command << " &"
+        end
+      end      
+      actual_command
+    end
+            
+    def windows?
+      PLATFORM['win32']
+    end
+    
+    def sh(command)
+      successful = system(command)
+      raise "Error while running >>#{command}<<" unless successful
+    end
+    
+  end
+
+end

data/lib/selenium.rb

@@ -21,13 +21,21 @@
 require 'net/http'
 require 'uri'
 require 'cgi'
+require "digest/md5"
+require "fileutils"
+require File.expand_path(File.dirname(__FILE__) + '/tcp_socket_extension')
+require File.expand_path(File.dirname(__FILE__) + '/nautilus/shell')
 require File.expand_path(File.dirname(__FILE__) + '/selenium/command_error')
 require File.expand_path(File.dirname(__FILE__) + '/selenium/protocol_error')
 require File.expand_path(File.dirname(__FILE__) + '/selenium/client/selenese_client')
 require File.expand_path(File.dirname(__FILE__) + '/selenium/client/generated_driver')
+require File.expand_path(File.dirname(__FILE__) + '/selenium/client/idiomatic')
 require File.expand_path(File.dirname(__FILE__) + '/selenium/client/base')
 require File.expand_path(File.dirname(__FILE__) + '/selenium/client/driver')
 require File.expand_path(File.dirname(__FILE__) + '/selenium/client/selenium_helper')
+require File.expand_path(File.dirname(__FILE__) + '/selenium/remote_control/remote_control')
+require File.expand_path(File.dirname(__FILE__) + '/selenium/rake/remote_control_start_task')
+require File.expand_path(File.dirname(__FILE__) + '/selenium/rake/remote_control_stop_task')
 
 # Backward compatibility
 

data/lib/selenium/client/base.rb

@@ -23,13 +23,14 @@ module Selenium
       include Selenium::Client::SeleneseClient
       include Selenium::Client::GeneratedDriver
   
-      def initialize(server_host, server_port, browserStartCommand, browserURL, timeout=30000)
+      def initialize(server_host, server_port, browser_string, browser_url, timeout_in_seconds=300)
         @server_host = server_host
         @server_port = server_port
-        @browserStartCommand = browserStartCommand
-        @browserURL = browserURL
-        @timeout = timeout
+        @browser_string = browser_string
+        @browser_url = browser_url
+        @timeout = timeout_in_seconds
         @extension_js = ""
+        @session_id = nil
       end
       
       def set_extension_js(extension_js)
@@ -37,7 +38,7 @@ module Selenium
       end
       
       def start()
-        result = get_string("getNewBrowserSession", [@browserStartCommand, @browserURL, @extension_js])
+        result = get_string("getNewBrowserSession", [@browser_string, @browser_url, @extension_js])
         @session_id = result
       end
       
@@ -46,6 +47,26 @@ module Selenium
         @session_id = nil
       end
 
+      def start_new_browser_session
+        start
+      end
+      
+      def close_current_browser_session
+        stop
+      end
+      
+      def session_started?
+        not @session_id.nil?
+      end
+      
+      def default_timeout_in_seconds
+        @timeout
+      end
+      
+      def chrome_backend?
+        ["*chrome", "*firefox", "*firefox2", "*firefox3"].include?(@browser_string)
+      end
+      
     end
   
   end

data/lib/selenium/client/driver.rb

@@ -3,6 +3,7 @@ module Selenium
     
     class Driver
       include Selenium::Client::Base
+      include Selenium::Client::Idiomatic
     end
   
   end

data/lib/selenium/client/idiomatic.rb

@@ -0,0 +1,179 @@
+#
+# Provide a more idiomatic API than the generated Ruby driver.
+#
+# Work on progress...
+#
+module Selenium
+  module Client
+    
+    module Idiomatic
+
+      # Return the text content of an HTML element (rendered text shown to
+      # the user). Works for any HTML element that contains text.
+      # 
+      #
+      # This command uses either the textContent (Mozilla-like browsers)
+      # or the innerText (IE-like browsers) of the element, which is the
+      # rendered text shown to the user.
+      #
+      # 'locator' is an Selenium element locator
+      def text_content(locator)
+        get_string "getText", [locator,]
+      end
+      
+      # Return the title of the current HTML page.
+      def title
+        get_string "getTitle"
+      end
+
+      # Returns the absolute URL of the current page.
+      def location
+        get_string "getLocation"
+      end
+
+      # Waits for a new page to load.
+      # 
+      # Selenium constantly keeps track of new pages loading, and sets a 
+      # "newPageLoaded" flag when it first notices a page load. Running 
+      # any other Selenium command after turns the flag to false. Hence, 
+      # if you want to wait for a page to load, you must wait immediately 
+      # after a Selenium command that caused a page-load.
+      # 
+      # 'timeout_in_seconds' is a timeout in seconds, after which this 
+      # command will return with an error
+      def wait_for_page(timeout_in_seconds=nil)
+          actual_timeout = timeout_in_seconds || default_timeout_in_seconds
+        do_command "waitForPageToLoad", [actual_timeout * 1000,]
+      end
+
+      # Gets the entire text of the page.
+      def body_text
+        get_string "getBodyText"
+      end
+
+      # Clicks on a link, button, checkbox or radio button. If the click action
+      # causes a new page to load (like a link usually does), call
+      # waitForPageToLoad.
+      #
+      # 'locator' is an element locator      
+      def click(locator, options={})
+        do_command("click", [locator,])        
+        if options[:wait_for] == :page
+          wait_for_page options[:timeout_in_seconds]
+        end
+      end
+
+      # Verifies that the specified text pattern appears somewhere on the rendered page shown to the user.
+      #
+      # 'pattern' is a pattern to match with the text of the page
+      def text_present?(pattern)
+        get_boolean "isTextPresent", [pattern,]
+      end
+
+      # Verifies that the specified element is somewhere on the page.
+      #
+      # 'locator' is an element locator
+      def element_present?(locator)
+        get_boolean "isElementPresent", [locator,]
+      end
+
+      # Gets the (whitespace-trimmed) value of an input field 
+      # (or anything else with a value parameter).
+      # For checkbox/radio elements, the value will be "on" or "off" 
+      # depending on whether the element is checked or not.
+      #
+      # 'locator' is an element locator
+      def value(locator)
+        get_string "getValue", [locator,]
+      end
+
+      # Whether an alert occurred
+      def alert?
+        get_boolean "isAlertPresent"
+      end
+
+      # Retrieves the message of a JavaScript alert generated during the previous action, 
+      # or fail if there were no alerts.
+      # 
+      # Getting an alert has the same effect as manually clicking OK. If an
+      # alert is generated but you do not consume it with getAlert, the next Selenium action
+      # will fail.
+      # Under Selenium, JavaScript alerts will NOT pop up a visible alert
+      # dialog.
+      # Selenium does NOT support JavaScript alerts that are generated in a
+      # page's onload() event handler. In this case a visible dialog WILL be
+      # generated and Selenium will hang until someone manually clicks OK.
+      # 
+      def alert
+        get_string "getAlert"
+      end
+      
+      # Whether a confirmation has been auto-acknoledged (i.e. confirm() been called)
+      def confirmation?
+        get_boolean "isConfirmationPresent"
+      end
+
+      # Retrieves the message of a JavaScript confirmation dialog generated during
+      # the previous action.
+      # 
+      # By default, the confirm function will return true, having the same effect
+      # as manually clicking OK. This can be changed by prior execution of the
+      # chooseCancelOnNextConfirmation command. 
+      # 
+      # If an confirmation is generated but you do not consume it with getConfirmation,
+      # the next Selenium action will fail.
+      # 
+      # NOTE: under Selenium, JavaScript confirmations will NOT pop up a visible
+      # dialog.
+      # 
+      # NOTE: Selenium does NOT support JavaScript confirmations that are
+      # generated in a page's onload() event handler. In this case a visible
+      # dialog WILL be generated and Selenium will hang until you manually click
+      # OK.
+      def confirmation
+        get_string "getConfirmation"
+      end
+
+      # Whether a prompt occurred
+      def prompt?
+        get_boolean "isPromptPresent"
+      end
+
+      # Retrieves the message of a JavaScript question prompt dialog generated during
+      # the previous action.
+      # 
+      # Successful handling of the prompt requires prior execution of the
+      # answerOnNextPrompt command. If a prompt is generated but you
+      # do not get/verify it, the next Selenium action will fail.
+      #
+      # NOTE: under Selenium, JavaScript prompts will NOT pop up a visible
+      # dialog.
+      #
+      # NOTE: Selenium does NOT support JavaScript prompts that are generated in a
+      # page's onload() event handler. In this case a visible dialog WILL be
+      # generated and Selenium will hang until someone manually clicks OK.
+      def prompt
+        get_string "getPrompt"
+      end
+
+      # Returns the result of evaluating the specified JavaScript snippet whithin the browser.
+      #  The snippet may have multiple lines, but only the result of the last line will be returned.
+      # 
+      # Note that, by default, the snippet will run in the context of the "selenium"
+      # object itself, so <tt>this</tt> will refer to the Selenium object.  Use <tt>window</tt> to
+      # refer to the window of your application, e.g. <tt>window.document.getElementById('foo')</tt>
+      # If you need to use
+      # a locator to refer to a single element in your application page, you can
+      # use <tt>this.browserbot.findElement("id=foo")</tt> where "id=foo" is your locator.
+      # 
+      # 'script' is the JavaScript snippet to run
+      def js_eval(script)
+        get_string "getEval", [script,]
+      end
+
+
+      # set speed
+    end
+  
+  end
+end

data/lib/selenium/client/selenese_client.rb

@@ -7,14 +7,14 @@ module Selenium
       attr_reader :session_id
   
       def do_command(verb, args)
-        timeout(@timeout) do
+        timeout(default_timeout_in_seconds) do
           status, response = http_post(http_request_for(verb, args))
           raise SeleniumCommandError, response unless status == "OK"          
           response
         end
       end
       
-      def get_string(verb, args)
+      def get_string(verb, args=[])
         do_command(verb, args)
       end
     
@@ -53,7 +53,7 @@ module Selenium
         return get_string_array(verb, args)
       end
 
-      def get_boolean(verb, args)
+      def get_boolean(verb, args=[])
         parse_boolean_value get_string(verb, args)
       end
     
@@ -82,10 +82,10 @@ module Selenium
       end
             
       def http_post(data)
-        #print "Requesting --->" + command_string + "\n"
+        # puts "Requesting ---> #{data.inspect}"
         http = Net::HTTP.new(@server_host, @server_port)
         response = http.post('/selenium-server/driver/', data, HTTP_HEADERS)
-        #print "RESULT: " + response.body + "\n\n"å          
+        # puts "RESULT: #{response.inspect}\n"       
         [ response.body[0..1], response.body[3..-1] ]
       end
       

data/lib/selenium/client/selenium_helper.rb

@@ -24,11 +24,11 @@ module Selenium
 
       # Passes all calls to missing methods to @selenium
       def method_missing(method_name, *args)
-          if args.empty?
-              @selenium.send(method_name)
-          else
-              @selenium.send(method_name, *args)
-          end
+        if args.empty?
+            @selenium.send(method_name)
+        else
+            @selenium.send(method_name, *args)
+        end
       end      
     end
     

data/lib/selenium/rake/remote_control_start_task.rb

@@ -0,0 +1,43 @@
+module Selenium
+  module Rake
+  
+    class RemoteControlStartTask
+      attr_accessor :port, :timeout_in_seconds, :background, 
+                    :wait_until_up_and_running, :additional_args
+      attr_reader :jar_file
+
+      def initialize(name = :'selenium:rc:start')
+        @name = name
+        @port = 4444
+        @timeout_in_seconds = 5
+        @jar_file = "vendor/selenium/selenium-server-1.0-standalone.jar"
+        @additional_args = []
+        @background = false
+        @wait_until_up_and_running = false
+        yield self if block_given?
+        define
+      end
+    
+      def jar_file=(new_jar_file)
+        @jar_file = File.expand_path(new_jar_file)
+      end
+      
+      def define
+        desc "Launch Selenium Remote Control"
+        task @name do
+          puts "Starting Selenium Remote Control at 0.0.0.0:#{@port}..."
+          remote_control = Selenium::RemoteControl::RemoteControl.new("0.0.0.0", @port, @timeout_in_seconds)
+          remote_control.jar_file = @jar_file
+          remote_control.additional_args = @additional_args
+          remote_control.start :background => @background
+          if @background && @wait_until_up_and_running
+            puts "Waiting for Remote Control to be up and running..."
+            TCPSocket.wait_for_service :host => @host, :port => @port
+          end
+          puts "Selenium Remote Control at 0.0.0.0:#{@port} ready"
+        end
+      end
+
+    end
+  end
+end

data/lib/selenium/rake/remote_control_stop_task.rb

@@ -0,0 +1,28 @@
+module Selenium
+  module Rake
+  
+    class RemoteControlStopTask
+      attr_accessor :host, :port, :timeout_in_seconds
+
+      def initialize(name = :'selenium:rc:stop')
+        @host = "localhost"
+        @name = name
+        @port = 4444
+        @timeout_in_seconds = 5
+        yield self if block_given?
+        define
+      end
+    
+      def define
+        desc "Stop Selenium Remote Control running"
+        task @name do
+          puts "Stopping Selenium Remote Control running at #{@host}:#{@port}..."
+          remote_control = Selenium::RemoteControl::RemoteControl.new(@host, @port, @timeout_in_seconds)
+          remote_control.stop
+          puts "Stopped Selenium Remote Control running at #{@host}:#{@port}"
+        end
+      end
+
+    end
+  end
+end

data/lib/selenium/rake/tasks.rb

@@ -0,0 +1,6 @@
+require "net/http"
+require File.expand_path(File.dirname(__FILE__) + '/../../nautilus/shell')
+require File.expand_path(File.dirname(__FILE__) + '/../../tcp_socket_extension')
+require File.expand_path(File.dirname(__FILE__) + '/../remote_control/remote_control')
+require File.expand_path(File.dirname(__FILE__) + '/remote_control_start_task')
+require File.expand_path(File.dirname(__FILE__) + '/remote_control_stop_task')

data/lib/selenium/remote_control/remote_control.rb

@@ -0,0 +1,30 @@
+module Selenium
+  module RemoteControl
+    
+    class RemoteControl
+      attr_reader :host, :port, :timeout_in_seconds
+      attr_accessor :additional_args, :jar_file
+      
+      def initialize(host, port, timeout_in_seconds = 2 * 60)
+        @host, @port, @timeout_in_seconds = host, port, timeout_in_seconds
+        @additional_args = []
+        @shell = Nautilus::Shell.new
+      end
+      
+      def start(options = {})
+        command = "java -jar \"#{jar_file}\""
+        command << " -port #{@port}"
+        command << " -timeout #{@timeout_in_seconds}"
+        command << " #{additional_args.join(' ')}" unless additional_args.empty?
+        
+        @shell.run command, {:background => options[:background]}
+      end
+      
+      def stop
+        Net::HTTP.get(@host, '/selenium-server/driver/?cmd=shutDown', @port)
+      end
+      
+    end
+    
+  end
+end