browserstack-webdriver 0.0.1

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,157 @@
+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:
+    #
+    #   require 'selenium/rake/server_task'
+    #
+    #   Selenium::Rake::ServerTask.new do |t|
+    #     t.jar = "/path/to/selenium-server-standalone.jar"
+    #     t.port = 4444
+    #     t.opts = %w[-some options]
+    #   end
+    #
+    # Alternatively, you can have the task download a specific version of the server:
+    #
+    #   Selenium::Rake::ServerTask.new(:server) do |t|
+    #     t.version = '2.6.0'
+    #   end
+    #
+    # or the latest version
+    #
+    #   Selenium::Rake::ServerTask.new(:server) do |t|
+    #     t.version = :latest
+    #   end
+    #
+    #
+    # Tasks defined:
+    #
+    #   rake selenium:server:start
+    #   rake selenium:server:stop
+    #   rake selenium:server:restart
+    #
+
+    class ServerTask
+      include ::Rake::DSL if defined?(::Rake::DSL)
+
+      #
+      # 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
+
+      #
+      # Specify the version of the server jar to download
+      #
+
+      attr_accessor :version
+
+
+      def initialize(prefix = "selenium:server")
+        @jar = nil
+        @prefix = prefix
+        @port = 4444
+        @timeout = 30
+        @background = true
+        @log = true
+        @opts = []
+        @version = nil
+
+        yield self if block_given?
+
+        if @version
+          @jar = Selenium::Server.download(@version)
+        end
+
+        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,248 @@
+require 'childprocess'
+require 'selenium/webdriver/common/socket_poller'
+require 'net/http'
+
+module Selenium
+
+  #
+  # Wraps the remote server jar
+  #
+  # Usage:
+  #
+  #   server = Selenium::Server.new('/path/to/selenium-server-standalone.jar')
+  #   server.start
+  #
+  # Automatically download the given version:
+  #
+  #   server = Selenium::Server.get '2.6.0'
+  #   server.start
+  #
+  # or the latest version:
+  #
+  #   server = Selenium::Server.get :latest
+  #   server.start
+  #
+  # Run the server in the background:
+  #
+  #   server = Selenium::Server.new(jar, :background => true)
+  #   server.start
+  #
+  # Add additional arguments:
+  #
+  #   server = Selenium::Server.new(jar)
+  #   server << ["--additional", "args"]
+  #   server.start
+  #
+
+  class Server
+    class Error < StandardError; end
+
+    CL_RESET = WebDriver::Platform.windows? ? '' : "\r\e[0K"
+
+    def self.get(required_version, opts = {})
+      new(download(required_version), opts)
+    end
+
+    #
+    # Download the given version of the selenium-server-standalone jar.
+    #
+
+    def self.download(required_version)
+      required_version = latest if required_version == :latest
+      download_file_name = "selenium-server-standalone-#{required_version}.jar"
+
+      if File.exists? download_file_name
+        return download_file_name
+      end
+
+      begin
+        open(download_file_name, "wb") do |destination|
+          net_http.start("selenium.googlecode.com") do |http|
+            resp = http.request_get("/files/#{download_file_name}") do |response|
+              total = response.content_length
+              progress = 0
+              segment_count = 0
+
+              response.read_body do |segment|
+                progress += segment.length
+                segment_count += 1
+
+                if segment_count % 15 == 0
+                  percent = (progress.to_f / total.to_f) * 100
+                  print "#{CL_RESET}Downloading #{download_file_name}: #{percent.to_i}% (#{progress} / #{total})"
+                  segment_count = 0
+                end
+
+                destination.write(segment)
+              end
+            end
+
+            unless resp.kind_of? Net::HTTPSuccess
+              raise Error, "#{resp.code} for #{download_file_name}"
+            end
+          end
+        end
+      rescue
+        FileUtils.rm download_file_name if File.exists? download_file_name
+        raise
+      end
+
+      download_file_name
+    end
+
+    #
+    # Ask Google Code what the latest selenium-server-standalone version is.
+    #
+
+    def self.latest
+      net_http.start("code.google.com") do |http|
+        resp = http.get("/p/selenium/downloads/list")
+        resp.body.to_s[/selenium-server-standalone-(\d+.\d+.\d+).jar/, 1]
+      end
+    end
+
+    #
+    # The server port
+    #
+
+    attr_accessor :port
+
+    #
+    # The server timeout
+    #
+
+    attr_accessor :timeout
+
+    #
+    # Whether to launch the server in the background
+    #
+
+    attr_accessor :background
+
+    #
+    # Path to log file, or 'true' for stdout.
+    #
+
+    attr_accessor :log
+
+    #
+    # @param [String] jar Path to the server jar.
+    # @param [Hash] opts the options to create the server process with
+    #
+    # @option opts [Integer] :port Port the server should listen on (default: 4444).
+    # @option opts [Integer] :timeout Seconds to wait for server launch/shutdown (default: 30)
+    # @option opts [true,false] :background Run the server in the background (default: false)
+    # @option opts [true,false,String] :log Either a path to a log file,
+    #                                      or true to pass server log to stdout.
+    # @raise [Errno::ENOENT] if the jar file does not exist
+    #
+
+    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
+
+      process.wait unless @background
+    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 self.net_http
+      http_proxy = ENV['http_proxy'] || ENV['HTTP_PROXY']
+
+      if http_proxy
+        http_proxy = "http://#{http_proxy}" unless http_proxy.start_with?("http://")
+        uri = URI.parse(http_proxy)
+
+        Net::HTTP::Proxy(uri.host, uri.port)
+      else
+        Net::HTTP
+      end
+    end
+
+    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)
+          @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 Error, "remote server not launched in #{@timeout} seconds"
+      end
+    end
+
+    def poll_for_shutdown
+      unless socket.closed?
+        raise Error, "remote server not stopped in #{@timeout} seconds"
+      end
+    end
+
+    def socket
+      @socket ||= WebDriver::SocketPoller.new(@host, @port, @timeout)
+    end
+
+  end # Server
+end # Selenium