browserstack-webdriver 0.0.1

data/lib/selenium/webdriver/remote/http/common.rb

@@ -0,0 +1,74 @@
+module Selenium
+  module WebDriver
+    module Remote
+      module Http
+        class Common
+          MAX_REDIRECTS   = 20 # same as chromium/gecko
+          CONTENT_TYPE    = "application/json"
+          DEFAULT_HEADERS = { "Accept" => CONTENT_TYPE }
+
+          attr_accessor :timeout
+          attr_writer :server_url
+
+          def initialize
+            @timeout = nil
+          end
+
+          def close
+            # hook for subclasses - will be called on Driver#quit
+          end
+
+          def call(verb, url, command_hash)
+            url      = server_url.merge(url) unless url.kind_of?(URI)
+            headers  = DEFAULT_HEADERS.dup
+            headers['Cache-Control'] = "no-cache" if verb == :get
+
+            if command_hash
+              payload                   = WebDriver.json_dump(command_hash)
+              headers["Content-Type"]   = "#{CONTENT_TYPE}; charset=utf-8"
+              headers["Content-Length"] = payload.bytesize.to_s if [:post, :put].include?(verb)
+
+              if $DEBUG
+                puts "   >>> #{url} | #{payload}"
+                puts "     > #{headers.inspect}"
+              end
+            elsif verb == :post
+              payload = "{}" # work around http://code.google.com/p/selenium/issues/detail?id=1396
+              headers["Content-Length"] = "2"
+            end
+
+            request verb, url, headers, payload
+          end
+
+          private
+
+          def server_url
+            @server_url or raise Error::WebDriverError, "server_url not set"
+          end
+
+          def request(verb, url, headers, payload)
+            raise NotImplementedError, "subclass responsibility"
+          end
+
+          def create_response(code, body, content_type)
+            code, body, content_type = code.to_i, body.to_s.strip, content_type.to_s
+            puts "<- #{body}\n" if $DEBUG
+
+            if content_type.include? CONTENT_TYPE
+              raise Error::WebDriverError, "empty body: #{content_type.inspect} (#{code})\n#{body}" if body.empty?
+              Response.new(code, WebDriver.json_load(body))
+            elsif code == 204
+              Response.new(code)
+            else
+              msg = "unexpected response, code=#{code}, content-type=#{content_type.inspect}"
+              msg << "\n#{body}" unless body.empty?
+
+              raise Error::WebDriverError, msg
+            end
+          end
+
+        end # Common
+      end # Http
+    end # Remote
+  end # WebDriver
+end # Selenium

data/lib/selenium/webdriver/remote/http/curb.rb

@@ -0,0 +1,79 @@
+require 'curb'
+
+module Selenium
+  module WebDriver
+    module Remote
+
+      # added for rescue
+      Bridge::QUIT_ERRORS << Curl::Err::RecvError
+
+      module Http
+
+        #
+        # An alternative to the default Net::HTTP client.
+        #
+        # This can be used for the Firefox and Remote drivers if you have Curb
+        # installed.
+        #
+        # @example Using Curb
+        #   require 'selenium/webdriver/remote/http/curb'
+        #   include Selenium
+        #
+        #   driver = WebDriver.for :firefox, :http_client => WebDriver::Remote::Http::Curb.new
+        #
+
+        class Curb < Common
+
+          private
+
+          def request(verb, url, headers, payload)
+            client.url     = url.to_s
+
+            # workaround for http://github.com/taf2/curb/issues/issue/40
+            # curb will handle this for us anyway
+            headers.delete "Content-Length"
+
+            client.headers = headers
+
+            # http://github.com/taf2/curb/issues/issue/33
+            client.head   = false
+            client.delete = false
+
+            case verb
+            when :get
+              client.http_get
+            when :post
+              client.post_body = payload || ""
+              client.http_post
+            when :put
+              client.put_data = payload || ""
+              client.http_put
+            when :delete
+              client.http_delete
+            when :head
+              client.http_head
+            else
+              raise Error::WebDriverError, "unknown HTTP verb: #{verb.inspect}"
+            end
+
+            create_response client.response_code, client.body_str, client.content_type
+          end
+
+          def client
+            @client ||= (
+              c = Curl::Easy.new
+
+              c.max_redirects   = MAX_REDIRECTS
+              c.follow_location = true
+              c.timeout         = @timeout if @timeout
+              c.verbose         = !!$DEBUG
+
+              c
+            )
+          end
+
+        end # Curb
+      end # Http
+    end # Remote
+  end # WebDriver
+end # Selenium

data/lib/selenium/webdriver/remote/http/default.rb

@@ -0,0 +1,139 @@
+require 'net/https'
+require 'ipaddr'
+
+module Selenium
+  module WebDriver
+    module Remote
+      module Http
+
+        # @api private
+        class Default < Common
+          attr_accessor :proxy
+
+          private
+
+          def http
+            @http ||= (
+              http = new_http_client
+              if server_url.scheme == "https"
+                http.use_ssl = true
+                http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+              end
+
+              if @timeout
+                http.open_timeout = @timeout
+                http.read_timeout = @timeout
+              end
+
+              http
+            )
+          end
+
+          MAX_RETRIES = 3
+
+          def request(verb, url, headers, payload, redirects = 0)
+            request = new_request_for(verb, url, headers, payload)
+
+            retries = 0
+            begin
+              response = response_for(request)
+            rescue Errno::ECONNABORTED, Errno::ECONNRESET, Errno::EADDRINUSE
+              # a retry is sometimes needed on Windows XP where we may quickly
+              # run out of ephemeral ports
+              #
+              # A more robust solution is bumping the MaxUserPort setting
+              # as described here:
+              #
+              # http://msdn.microsoft.com/en-us/library/aa560610%28v=bts.20%29.aspx
+              raise if retries >= MAX_RETRIES
+
+              request = new_request_for(verb, url, headers, payload)
+              retries += 1
+
+              retry
+            rescue Errno::ECONNREFUSED => ex
+              if use_proxy?
+                raise ex.class, "using proxy: #{proxy.http}"
+              else
+                raise
+              end
+            end
+
+            if response.kind_of? Net::HTTPRedirection
+              raise Error::WebDriverError, "too many redirects" if redirects >= MAX_REDIRECTS
+              request(:get, URI.parse(response['Location']), DEFAULT_HEADERS.dup, nil, redirects + 1)
+            else
+              create_response response.code, response.body, response.content_type
+            end
+          end
+
+          def new_request_for(verb, url, headers, payload)
+            req = Net::HTTP.const_get(verb.to_s.capitalize).new(url.path, headers)
+
+            if server_url.userinfo
+              req.basic_auth server_url.user, server_url.password
+            end
+
+            req.body = payload if payload
+
+            req
+          end
+
+          def response_for(request)
+            http.request request
+          end
+
+          def new_http_client
+            if use_proxy?
+              unless proxy.respond_to?(:http) && url = @proxy.http
+                raise Error::WebDriverError, "expected HTTP proxy, got #{@proxy.inspect}"
+              end
+
+              proxy = URI.parse(url)
+
+              clazz = Net::HTTP::Proxy(proxy.host, proxy.port, proxy.user, proxy.password)
+              clazz.new(server_url.host, server_url.port)
+            else
+              Net::HTTP.new server_url.host, server_url.port
+            end
+          end
+
+          def proxy
+            @proxy ||= (
+              proxy = ENV['http_proxy'] || ENV['HTTP_PROXY']
+              no_proxy = ENV['no_proxy'] || ENV['NO_PROXY']
+
+              if proxy
+                proxy = "http://#{proxy}" unless proxy.start_with?("http://")
+                Proxy.new(:http => proxy, :no_proxy => no_proxy)
+              end
+            )
+          end
+
+          def use_proxy?
+            return false if proxy.nil?
+
+            if proxy.no_proxy
+              ignored = proxy.no_proxy.split(",").any? do |host|
+                host == "*" ||
+                host == server_url.host || (
+                  begin
+                    IPAddr.new(host).include?(server_url.host)
+                  rescue ArgumentError => ex
+                    false
+                  end
+                )
+
+              end
+
+              not ignored
+            else
+              true
+            end
+          end
+
+        end # Default
+      end # Http
+    end # Remote
+  end # WebDriver
+end # Selenium

data/lib/selenium/webdriver/remote/http/persistent.rb

@@ -0,0 +1,38 @@
+require 'net/http/persistent'
+
+module Selenium
+  module WebDriver
+    module Remote
+      module Http
+
+        # @api private
+        class Persistent < Default
+
+          def close
+            @http.shutdown if @http
+          end
+
+          private
+
+          def new_http_client
+            proxy = nil
+
+            if @proxy
+              unless @proxy.respond_to?(:http) && url = @proxy.http
+                raise Error::WebDriverError, "expected HTTP proxy, got #{@proxy.inspect}"
+              end
+              proxy = URI.parse(url)
+            end
+
+            Net::HTTP::Persistent.new "webdriver", proxy
+          end
+
+          def response_for(request)
+            http.request server_url, request
+          end
+
+        end # Persistent
+      end # Http
+    end # Remote
+  end # WebDriver
+end # Selenium

data/lib/selenium/webdriver/remote/response.rb

@@ -0,0 +1,97 @@
+module Selenium
+  module WebDriver
+    module Remote
+
+      # @api private
+      class Response
+
+        attr_reader :code, :payload
+        attr_writer :payload
+
+        def initialize(code, payload = nil)
+          @code    = code
+          @payload = payload || {}
+
+          assert_ok
+        end
+
+        def error
+          klass = Error.for_code(status) || return
+
+          ex = klass.new(error_message)
+          ex.set_backtrace(caller)
+          add_backtrace ex
+
+          ex
+        end
+
+        def error_message
+          val = value
+
+          case val
+          when Hash
+            msg = val['message'] or return "unknown error"
+            msg << " (#{ val['class'] })" if val['class']
+          when String
+            msg = val
+          else
+            msg = "unknown error, status=#{status}: #{val.inspect}"
+          end
+
+          msg
+        end
+
+        def [](key)
+          @payload[key]
+        end
+
+        private
+
+        def assert_ok
+          if e = error()
+            raise e
+          elsif @code.nil? || @code >= 400
+            raise Error::ServerError, self
+          end
+        end
+
+        def add_backtrace(ex)
+          unless value.kind_of?(Hash) && value['stackTrace']
+            return
+          end
+
+          server_trace = value['stackTrace']
+
+          backtrace = server_trace.map do |frame|
+            next unless frame.kind_of?(Hash)
+
+            file = frame['fileName']
+            line = frame['lineNumber']
+            meth = frame['methodName']
+
+            if class_name = frame['className']
+              file = "#{class_name}(#{file})"
+            end
+
+            if meth.nil? || meth.empty?
+              meth = 'unknown'
+            end
+
+            "[remote server] #{file}:#{line}:in `#{meth}'"
+          end.compact
+
+          ex.set_backtrace(backtrace + ex.backtrace)
+        end
+
+        def status
+          @payload['status']
+        end
+
+        def value
+          @payload['value']
+        end
+
+      end # Response
+    end # Remote
+  end # WebDriver
+end # Selenium

data/lib/selenium/webdriver/remote/server_error.rb

@@ -0,0 +1,17 @@
+module Selenium
+  module WebDriver
+    module Error
+      class ServerError < StandardError
+
+        def initialize(response)
+          if response.kind_of? String
+            super(response)
+          else
+            super("status code #{response.code}")
+          end
+        end
+      end
+
+    end # Error
+  end # WebDriver
+end # Selenium