selenium-webdriver 0.0.29 → 0.1.0

data/lib/selenium/client/protocol.rb

@@ -0,0 +1,104 @@
+module Selenium
+  module Client
+
+    HTTP_HEADERS = { 'Content-Type' => 'application/x-www-form-urlencoded; charset=utf-8' }
+
+    # Module in charge of handling Selenium over-the-wire HTTP protocol
+    module Protocol
+      attr_reader :session_id
+
+      def remote_control_command(verb, args=[])
+        timeout(@default_timeout_in_seconds) do
+          status, response = http_post(http_request_for(verb, args))
+          raise CommandError, response unless status == "OK"
+          response[3..-1] # strip "OK," from response
+        end
+      end
+
+      def string_command(verb, args=[])
+        remote_control_command(verb, args)
+      end
+
+      def string_array_command(verb, args=[])
+        csv = string_command(verb, args)
+        token = ""
+        tokens = []
+        escape = false
+        csv.split(//).each do |letter|
+          if escape
+            token += letter
+            escape = false
+            next
+          end
+          case letter
+            when '\\'
+              escape = true
+            when ','
+              tokens << token
+              token = ""
+            else
+              token += letter
+          end
+        end
+        tokens << token
+        return tokens
+      end
+
+      def number_command(verb, args)
+        string_command verb, args
+      end
+
+      def number_array_command(verb, args)
+        string_array_command verb, args
+      end
+
+      def boolean_command(verb, args=[])
+        parse_boolean_value string_command(verb, args)
+      end
+
+      def boolean_array_command(verb, args)
+        string_array_command(verb, args).collect {|value| parse_boolean_value(value)}
+      end
+
+      protected
+
+      def parse_boolean_value(value)
+        if ("true" == value)
+            return true
+        elsif ("false" == value)
+            return false
+        end
+        raise ProtocolError, "Invalid Selenese boolean value that is neither 'true' nor 'false': got '#{value}'"
+      end
+
+      def http_request_for(verb, args)
+        data = "cmd=#{CGI::escape(verb)}"
+        args.each_with_index do |arg, index|
+          data << "&#{index.succ}=#{CGI::escape(arg.to_s)}"
+        end
+        data << "&sessionId=#{session_id}" unless session_id.nil?
+        data
+      end
+
+      def http_post(data)
+        start = Time.now
+        called_from = caller.detect{|line| line !~ /(selenium-client|vendor|usr\/lib\/ruby|\(eval\))/i}
+        http = Net::HTTP.new(@host, @port)
+        http.open_timeout = default_timeout_in_seconds
+        http.read_timeout = default_timeout_in_seconds
+        response = http.post('/selenium-server/driver/', data, HTTP_HEADERS)
+        if response.body !~ /^OK/
+          puts "#{start} selenium-client received failure from selenium server:"
+          puts "requested:"
+          puts "\t" + CGI::unescape(data.split('&').join("\n\t"))
+          puts "received:"
+          puts "\t#{response.body.inspect}"
+          puts "\tcalled from #{called_from}"
+        end
+        [ response.body[0..1], response.body ]
+      end
+
+    end
+
+  end
+end

data/lib/selenium/client/selenium_helper.rb

@@ -0,0 +1,34 @@
+# Defines a mixin module that you can use to write Selenium tests
+# without typing "@selenium." in front of every command.  Every
+# call to a missing method will be automatically sent to the @selenium
+# object.
+module Selenium
+  module Client
+    
+    module SeleniumHelper
+    
+      # Overrides default open method to actually delegates to @selenium
+      def open(url)
+        @selenium.open url
+      end
+    
+      # Overrides default type method to actually delegates to @selenium
+      def type(locator, value)
+        @selenium.type locator, value
+      end
+    
+      # Overrides default select method to actually delegates to @selenium
+      def select(input_locator, option_locator)
+        @selenium.select input_locator, option_locator
+      end
+
+      # Delegates to @selenium on method missing 
+      def method_missing(method_name, *args)
+        return super unless @selenium.respond_to?(method_name)
+        
+        @selenium.send(method_name, *args)
+      end                  
+    end
+    
+  end
+end

data/lib/selenium/rake/server_task.rb

@@ -0,0 +1,131 @@
+require 'selenium/server'
+require 'rake'
+
+module Selenium
+  module Rake
+
+    class MissingJarFileError < StandardError
+    end
+
+
+    #
+    # Defines rake tasks for starting, stopping and restarting the Selenium server.
+    #
+    # Usage:
+    #
+    #   Selenium::Rake::ServerTask.new do |t|
+    #     t.jar = "/path/to/selenium-server-standalone.jar"
+    #     t.port = 4444
+    #     t.opts = %w[-some options]
+    #   end
+    #
+    # Tasks defined:
+    #
+    # rake selenium:server:start
+    # rake selenium:server:stop
+    # rake selenium:server:restart
+    #
+
+    class ServerTask
+
+      #
+      # Path to the selenium server jar
+      #
+
+      attr_accessor :jar
+
+      #
+      # Port to use for the server.
+      # Default: 4444
+      #
+      #
+
+      attr_accessor :port
+
+      #
+      # Timeout in seconds for the server to start/stop.
+      # Default: 30
+      #
+
+      attr_accessor :timeout
+
+      #
+      # Whether we should detach from the server process.
+      # Default: true
+      #
+
+      attr_accessor :background
+      alias_method :background?, :background
+
+      #
+      # Configure logging. Pass a log file path or a boolean.
+      # Default: true
+      #
+      # true  - log to stdout/stderr
+      # false - no logging
+      # String - log to the specified file
+      #
+
+      attr_accessor :log
+
+      #
+      # Add additional options passed to the server jar.
+      #
+
+      attr_accessor :opts
+
+
+      def initialize(prefix = "selenium:server")
+        @jar = nil
+        @prefix = prefix
+        @port = 4444
+        @timeout = 30
+        @background = true
+        @log = true
+        @opts = []
+
+        yield self if block_given?
+
+        unless @jar
+          raise MissingJarFileError, "must provide path to the selenium server jar"
+        end
+
+        @server = Selenium::Server.new(@jar, :port       => @port,
+                                             :timeout    => @timeout,
+                                             :background => @background,
+                                             :log        => @log )
+
+        @server << @opts
+
+        define_start_task
+        define_stop_task
+        define_restart_task
+      end
+
+      private
+
+      def define_start_task
+        desc "Start the Selenium server"
+        task "#{@prefix}:start" do
+          @server.start
+        end
+      end
+
+      def define_stop_task
+        desc 'Stop the Selenium server'
+        task "#{@prefix}:stop" do
+          @server.stop
+        end
+      end
+
+      def define_restart_task
+        desc 'Restart the Selenium server'
+        task "#{@prefix}:restart" do
+          @server.stop
+          @server.start
+        end
+      end
+
+    end # ServerTask
+  end # Rake
+end # Selenium

data/lib/selenium/server.rb

@@ -0,0 +1,114 @@
+require "childprocess"
+require "selenium/webdriver/common/socket_poller"
+require "net/http"
+
+module Selenium
+
+  #
+  # Wraps the remote server jar
+  #
+
+  class Server
+
+    def initialize(jar, opts = {})
+      raise Errno::ENOENT, jar unless File.exist?(jar)
+
+      @jar        = jar
+      @host       = "127.0.0.1"
+      @port       = opts.fetch(:port, 4444)
+      @timeout    = opts.fetch(:timeout, 30)
+      @background = opts.fetch(:background, false)
+      @log        = opts[:log]
+
+      @additional_args = []
+    end
+
+    def start
+      process.start
+      poll_for_service
+
+      unless @background
+        begin
+          sleep 1 while process.alive?
+        rescue Errno::ECHILD
+          # no longer alive
+        end
+      end
+    end
+
+    def stop
+      begin
+        Net::HTTP.get(@host, "/selenium-server/driver/?cmd=shutDownSeleniumServer", @port)
+      rescue Errno::ECONNREFUSED
+      end
+
+      stop_process if @process
+      poll_for_shutdown
+
+      @log_file.close if @log_file
+    end
+
+    def webdriver_url
+      "http://#{@host}:#{@port}/wd/hub"
+    end
+
+    def <<(arg)
+      if arg.kind_of?(Array)
+        @additional_args += arg
+      else
+        @additional_args << arg.to_s
+      end
+    end
+
+    private
+
+    def stop_process
+      return unless @process.alive?
+
+      begin
+        @process.poll_for_exit(5)
+      rescue ChildProcess::TimeoutError
+        @process.stop
+      end
+    rescue Errno::ECHILD
+      # already dead
+    ensure
+      @process = nil
+    end
+
+    def process
+      @process ||= (
+        cp = ChildProcess.build("java", "-jar", @jar, "-port", @port.to_s, *@additional_args)
+        io = cp.io
+
+        if @log.kind_of?(String) && !@background
+          @log_file = File.open(@log, "w")
+          io.stdout = io.stderr = @log_file
+        elsif @log
+          io.inherit!
+        end
+
+        cp.detach = @background
+
+        cp
+      )
+    end
+
+    def poll_for_service
+      unless socket.connected?
+        raise "remote server not launched in #{@timeout} seconds"
+      end
+    end
+
+    def poll_for_shutdown
+      unless socket.closed?
+        raise "remote server not stopped in #{@timeout} seconds"
+      end
+    end
+
+    def socket
+      @socket ||= WebDriver::SocketPoller.new(@host, @port, @timeout)
+    end
+
+  end # Server
+end # Selenium

data/lib/selenium/webdriver.rb

@@ -27,15 +27,16 @@ end
 
 require "selenium/webdriver/common"
 
-
 module Selenium
   module WebDriver
     Point     = Struct.new(:x, :y)
     Dimension = Struct.new(:width, :height)
 
+    autoload :Android, 'selenium/webdriver/android'
+    autoload :Chrome,  'selenium/webdriver/chrome'
     autoload :IE,      'selenium/webdriver/ie'
+    autoload :IPhone,  'selenium/webdriver/iphone'
     autoload :Remote,  'selenium/webdriver/remote'
-    autoload :Chrome,  'selenium/webdriver/chrome'
     autoload :Firefox, 'selenium/webdriver/firefox'
 
     def self.root

data/lib/selenium/webdriver/android.rb

@@ -0,0 +1,9 @@
+module Selenium
+  module WebDriver
+    module Android
+
+    end # Android
+  end # WebDriver
+end # Selenium
+
+require "selenium/webdriver/android/bridge"

data/lib/selenium/webdriver/android/bridge.rb

@@ -0,0 +1,45 @@
+module Selenium
+  module WebDriver
+    module Android
+      class Bridge < Remote::Bridge
+
+        DEFAULT_URL = "http://localhost:8080/hub"
+
+        def initialize(opts = nil)
+          if opts
+            super
+          else
+            super(
+              :url                  => DEFAULT_URL,
+              :desired_capabilities => capabilities
+            )
+          end
+        end
+
+        def browser
+          :android
+        end
+
+        def driver_extensions
+          [
+            DriverExtensions::TakesScreenshot,
+            DriverExtensions::Rotatable
+          ]
+        end
+
+        def setScreenOrientation(orientation)
+          execute :setScreenOrientation, {}, :orientation => orientation
+        end
+
+        def getScreenOrientation
+          execute :getScreenOrientation
+        end
+
+        def capabilities
+          @capabilities ||= Remote::Capabilities.android
+        end
+
+      end # Bridge
+    end # Android
+  end # WebDriver
+end # Selenium