jacobdam-selenium 1.1.16

data/lib/selenium/selenium_server.rb

@@ -0,0 +1,86 @@
+require 'net/http'
+
+module Selenium
+
+  # Selenium server driver that provides API to start/stop server and check if
+  # server is running.
+  # NOTE: The start does not return until the server shuts down.
+  class SeleniumServer
+
+    def SeleniumServer::run(argv, vmparameter='')
+      jar_file = SeleniumServer.jar_file
+      if (argv[0] == '-stop')
+        server = SeleniumServer.new(argv[1])
+        puts "stopping server on port #{server.port_number}"
+        server.stop
+      elsif argv[0] == '-check'
+        server = SeleniumServer.new(argv[1])
+        if (server.running?)
+          puts "server running on #{server.port_number}"
+        else
+          puts "server not running on #{server.port_number}"
+        end
+      else
+        command = "java #{vmparameter} -jar #{jar_file} #{argv.join(' ')}"
+        puts command
+        system(command)
+      end
+    end
+
+    private
+    def SeleniumServer::jar_file
+      File.join(File.dirname(__FILE__), 'openqa', 'selenium-server.jar.txt')
+    end
+
+    public
+    attr_reader :port_number, :request_timeout
+    # Turn off INFO level server logs, only WARN and above message will be printed
+    attr_accessor :print_log
+
+    # Initialize the server driver with an opitonal port number (default to 4444)
+    # and request timeout (default to 30)
+    def initialize(port_number_to_use = 4444, request_timeout=30)
+      port_number_to_use = 4444 unless port_number_to_use
+      @port_number = port_number_to_use
+      @request_timeout = request_timeout
+      @print_log = false
+    end
+
+    def port_number
+      @port_number
+    end
+
+    # Starts the Selenium server.  This does not return until the server is shutdown.
+    def start(*argv)
+      logging_option = ''
+      logging_option = '-Dorg.apache.commons.logging.Log=org.apache.commons.logging.impl.SimpleLog -Dorg.apache.commons.logging.simplelog.defaultlog=warn' unless @print_log
+      SeleniumServer.run(['-port', port_number.to_s, '-timeout', request_timeout.to_s] + argv, logging_option)
+    end
+
+    # Stops the Selenium server
+    def stop
+      Net::HTTP.get('localhost', '/selenium-server/driver/?cmd=shutDownSeleniumServer', @port_number)
+    end
+
+    # Check if the Selenium is running by sending a test_complete command with invalid session ID
+    def running?
+      begin
+        ping
+      rescue Errno::EBADF, Errno::ECONNREFUSED => e
+        return false
+      end
+      return true
+    end
+
+    # ping the server to see if it is running, raises error if not
+    # returns the ping status
+    def ping
+      url = URI.parse("http://localhost:#{@port_number}/selenium-server/driver/?cmd=testComplete&sessionId=smoketest")
+      request = Net::HTTP::Get.new(url.path)
+      Net::HTTP.start(url.host, url.port) {|http|
+        http.read_timeout=5
+        http.request(request)
+      }
+    end
+  end
+end

data/lib/selenium/server.rb

@@ -0,0 +1,124 @@
+require 'uri'
+
+module Selenium
+# The class that can manages the server driver classes.
+# This class is originally copied from the BuildMaster project.
+# You can setup your build task to start the server before
+# the tests and shutdown when it is finished
+#   server = Selenium::Server.new()
+#   begin
+#     server.start
+#     tests.run # run your tests here
+#   ensure
+#     server.stop
+#   end
+class Server
+  # The status of the server.  Values are
+  # * stopped
+  # * starting
+  # * started
+  # * stopping
+  # * error
+  attr_reader :status
+
+  # The timeout setting for selenium in seconds
+  attr_reader :timeout
+
+  def Server::on_port(port)
+    Server.new(SeleniumServer.new(port))
+  end
+
+  # Create a selenium server that can be controlled directly
+  def initialize(port_number, timeout=60)
+    if port_number.is_a? SeleniumServer
+      # backward compatibility, to be removed in 2.0
+      @server = port_number 
+    else
+      @server = SeleniumServer.new(port_number, timeout)
+    end
+    @status = 'stopped'
+  end
+
+  def print_log=(value)
+    @server.print_log = value
+  end
+
+  # Starts the server, returns when the server is up and running
+  def start(*argv)
+    puts "starting selenium server..."
+    starting_server(*argv)
+    wait_for_condition {@server.running?}
+    puts "started selenium server"
+    @status = 'started'
+  end
+
+  def driver(browser_start_command, browser_url)
+    SeleniumDriver.new('localhost', @server.port_number, browser_start_command, browser_url, @server.request_timeout * 1000)
+  end
+
+  def open(browser_start_command, browser_url)
+    url = URI.parse(browser_url)
+    browser = driver(browser_start_command, URI::Generic::new(url.scheme, url.userinfo, url.host, url.port, nil, nil, nil, nil, nil))
+    browser.start
+    browser.open(url.request_uri)
+    page = WebPage.new(browser)
+    page.wait_for_load
+    page
+  end
+
+  # Starts the server, does not return until the server shuts down
+  def run(*argv)
+    @server.start(*argv)
+  end
+
+  # Stops the server, returns when the server is no longer running
+  def stop
+    puts "stopping selenium server..."
+    stopping_server
+    wait_for_condition {not @server.running?}
+    puts "stopped selenium server."
+    @status = 'stopped'
+  end
+
+  private
+  def starting_server(*argv)
+    @status = 'starting'
+    ['INT', 'TERM'].each { |signal|
+         trap(signal){ @server.stop}
+    }
+    start_thread {run(*argv)}
+  end
+
+  def stopping_server
+    @status = 'stopping'
+    start_thread {@server.stop}
+  end
+
+  def start_thread
+    Thread.new do
+      begin
+        yield
+      rescue Exception => exception
+        @exception = exception
+      end
+    end
+  end
+
+  def wait_for_condition
+    count = 0
+    sleep 1
+    while not (result = yield)
+      if (@exception)
+        error = @exception
+        @exception = nil
+        @status = 'error'
+        raise error
+      end
+      count = count + 1
+      raise 'wait timed out' unless count < 10
+      sleep 1
+    end
+  end
+
+end
+end

data/lib/selenium/server_manager.rb

@@ -0,0 +1,10 @@
+
+
+module Selenium
+
+require 'server'
+# Renamed to Server for simplicity
+class ServerManager < Server
+
+end
+end

data/lib/selenium/text_area.rb

@@ -0,0 +1,15 @@
+module Selenium
+class TextArea < HtmlElement
+  def initialize(webpage, locator)
+    super(webpage, locator)
+  end
+
+  def enter(value)
+    @webpage.enter(@locator, value)
+  end
+
+  def value
+    @webpage.value(@locator)
+  end
+end
+end

data/lib/selenium/text_field.rb

@@ -0,0 +1,16 @@
+module Selenium
+class TextField < HtmlElement
+  
+  def initialize(webpage, locator)
+    super(webpage, locator)
+  end
+  
+  def enter(value)
+    @webpage.enter(locator, value)
+  end
+  
+  def value
+    @webpage.value(locator)
+  end
+end
+end

data/lib/selenium/web_page.rb

@@ -0,0 +1,214 @@
+$:.unshift File.dirname(__FILE__)
+
+require 'timeout'
+
+module Selenium
+  # Error that is thrown when a key is not supported
+  class NoKeyError < NameError
+    def initialize(key)
+      super(key)
+    end
+  end
+
+  # Class that models a web page with a title
+  class WebPage
+    attr_reader :browser
+    attr_accessor :timeout, :interval_millis
+
+    def initialize(browser, expected_title = nil)
+      @browser = browser
+      @expected_title = expected_title
+      @timeout = 60
+      @interval_millis = 100
+    end
+
+    def title
+      raise 'nil as browser' unless @browser
+      @browser.get_title
+    end
+
+    def present?
+      title == @expected_title
+    end
+
+    def ensure_present
+      title.should == @expected_title
+    end
+
+    def html
+      @browser.get_html_source
+    end
+
+    def speed=(value)
+      @browser.set_speed(value)
+    end
+
+    def speed
+      @browser.get_speed.to_i
+    end
+
+    def wait_for_load
+      @browser.wait_for_page_to_load
+    end
+
+    def wait_until(message, &block)
+      Timeout::timeout(timeout, "Timeout waiting for : #{message}") do
+        while(not yield message)
+          sleep interval_millis / 1000.0
+        end
+      end
+    end
+
+    def alert
+      Alert.new(self)
+    end
+
+    def link(how, what=nil)
+      if (how == :text)
+        locator = "link=#{what}"
+      elsif (how == :href)
+        locator = "xpath=//a[@href='#{what}']"
+      else
+        locator = element_locator(how, what)
+      end
+      Link.new(self, locator)
+    end
+
+    def text_field(how, what=nil)
+      TextField.new(self, element_locator(how, what))
+    end
+
+    def text_area(how, what=nil)
+      TextArea.new(self, element_locator(how, what))
+    end
+
+    def element(how, what=nil)
+      HtmlElement.new(self, element_locator(how,what))
+    end
+
+    def element_locator(how, what=nil)
+      locator = how
+      if (not what.nil?)
+        if (how == :xpath or how == :name or how == :id)
+          locator = "#{how}=#{what}"
+        else
+          raise "couldn't understand how to build locator using #{how} with #{what}"
+        end
+      end
+      locator
+    end
+
+    def file_upload(how, what)
+      FileUpload.new(self, element_locator(how, what))
+    end
+
+    def open_page(url)
+      @browser.open(url)
+      wait_for_load
+    end
+
+    def close
+      @browser.stop
+    end
+
+    def click(locator)
+      @browser.click(locator)
+    end
+
+    def text(locator)
+      @browser.get_text(locator)
+    end
+
+    def button(how, what=nil)
+      Button.new(self, element_locator(how, what))
+    end
+
+    def key(key)
+      Key.new(self, key)
+    end
+
+    def element_present?(locator)
+      @browser.is_element_present(locator)
+    end
+
+    def alert_present?
+      @browser.is_alert_present
+    end
+
+    def text_present?(text)
+      @browser.is_text_present(text)
+    end
+
+    def double_click(locator)
+      @browser.double_click(locator)
+    end
+
+    def click_wait(locator)
+      click(locator)
+      wait_for_load
+    end
+
+    # enter the text to the element found by locator
+    def enter(locator, text)
+      @browser.type(locator, text)
+    end
+
+    def value(locator)
+      @browser.get_value(locator)
+    end
+
+    def alert_message
+      @browser.get_alert
+    end
+
+    def context_menu(locator)
+      @browser.context_menu(locator)
+    end
+
+    def fire_event(locator, event)
+      @browser.fire_event(locator, event)
+    end
+
+    def key_down(key)
+      message = "#{key}_key_down"
+      raise NoKeyError.new(key.to_s) unless @browser.respond_to? message
+      @browser.send message
+    end
+
+    def key_up(key)
+      message = "#{key}_key_up"
+      raise NoKeyError.new(key.to_s) unless @browser.respond_to? message
+      @browser.send message
+    end
+
+    def key_press(locator, key)
+      @browser.key_press(locator, key)
+    end
+
+    def focus(locator)
+      @browser.focus(locator)
+    end
+
+    def upload(locator, file)
+#      @browser.attach_file(locator, file)
+      @browser.click(locator)
+      require 'auto_it'
+      autoit = AutoIt.load
+      window = AutoItWindow.wait_for(autoit, 'File Upload')
+      puts window
+    end
+
+    def capture_page(file)
+      @browser.capture_entire_page_screenshot(file)
+    end
+
+    def capture_screen(file)
+      @browser.capture_screenshot(file)
+    end
+
+    def to_s
+      "#{self.class}('#{@expected_title}') - #{browser.to_s}"
+    end
+	
+  end
+end