bbc-selenium-webdriver 1.17.0

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,102 @@
+require 'net/https'
+
+module Selenium
+  module WebDriver
+    module Remote
+      module Http
+
+        # @api private
+        class Default < Common
+          attr_accessor :proxy
+
+          private
+
+          def initialize
+            super
+            @proxy = nil
+          end
+
+          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
+            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 @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
+
+        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,99 @@
+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 @code.nil? || @code >= 400
+            if e = error()
+              raise e
+            else
+              raise Error::ServerError, self
+            end
+          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

data/lib/selenium/webdriver/support.rb

@@ -0,0 +1,4 @@
+require 'selenium/webdriver/support/event_firing_bridge'
+require 'selenium/webdriver/support/abstract_event_listener'
+require 'selenium/webdriver/support/block_event_listener'
+require 'selenium/webdriver/support/select'

data/lib/selenium/webdriver/support/abstract_event_listener.rb

@@ -0,0 +1,28 @@
+module Selenium
+  module WebDriver
+    module Support
+
+      class AbstractEventListener
+        def before_navigate_to(url, driver) end
+        def after_navigate_to(url, driver) end
+        def before_navigate_back(driver) end
+        def after_navigate_back(driver) end
+        def before_navigate_forward(driver) end
+        def after_navigate_forward(driver) end
+        def before_find(by, what, driver) end
+        def after_find(by, what, driver) end
+        def before_click(element, driver) end
+        def after_click(element, driver) end
+        def before_change_value_of(element, driver) end
+        def after_change_value_of(element, driver) end
+        def before_execute_script(script, driver) end
+        def after_execute_script(script, driver) end
+        def before_quit(driver) end
+        def after_quit(driver) end
+        def before_close(driver) end
+        def after_close(driver) end
+      end
+
+    end
+  end
+end

data/lib/selenium/webdriver/support/block_event_listener.rb

@@ -0,0 +1,17 @@
+module Selenium
+  module WebDriver
+    module Support
+
+      class BlockEventListener
+        def initialize(callback)
+          @callback = callback
+        end
+
+        def method_missing(meth, *args, &blk)
+          @callback.call meth, *args
+        end
+      end
+
+    end
+  end
+end

data/lib/selenium/webdriver/support/event_firing_bridge.rb

@@ -0,0 +1,112 @@
+module Selenium
+  module WebDriver
+    module Support
+
+      #
+      # @api private
+      #
+
+      class EventFiringBridge
+        def initialize(delegate, listener)
+          @delegate = delegate
+
+          if listener.respond_to? :call
+            @listener = BlockEventListener.new(listener)
+          else
+            @listener = listener
+          end
+        end
+
+        def get(url)
+          dispatch(:navigate_to, url, driver) {
+            @delegate.get(url)
+          }
+        end
+
+        def goForward
+          dispatch(:navigate_forward, driver) {
+            @delegate.goForward
+          }
+        end
+
+        def goBack
+          dispatch(:navigate_back, driver) {
+            @delegate.goBack
+          }
+        end
+
+        def clickElement(ref)
+          dispatch(:click, create_element(ref), driver) {
+            @delegate.clickElement(ref)
+          }
+        end
+
+        def clearElement(ref)
+          dispatch(:change_value_of, create_element(ref), driver) {
+            @delegate.clearElement(ref)
+          }
+        end
+
+        def sendKeysToElement(ref, keys)
+          dispatch(:change_value_of, create_element(ref), driver) {
+            @delegate.sendKeysToElement(ref, keys)
+          }
+        end
+
+        def find_element_by(how, what, parent = nil)
+          e = dispatch(:find, how, what, driver) {
+            @delegate.find_element_by how, what, parent
+          }
+
+          Element.new self, e.ref
+        end
+
+        def find_elements_by(how, what, parent = nil)
+          es = dispatch(:find, how, what, driver) {
+            @delegate.find_elements_by(how, what, parent)
+          }
+
+          es.map { |e| Element.new self, e.ref }
+        end
+
+        def executeScript(script, *args)
+          dispatch(:execute_script, script, driver) {
+            @delegate.executeScript(script, *args)
+          }
+        end
+
+        def quit
+          dispatch(:quit, driver) { @delegate.quit }
+        end
+
+        def close
+          dispatch(:close, driver) { @delegate.close }
+        end
+
+        private
+
+        def create_element(ref)
+          # hmm. we're not passing self here to not fire events for potential calls made by the listener
+          Element.new @delegate, ref
+        end
+
+        def driver
+          @driver ||= Driver.new(self)
+        end
+
+        def dispatch(name, *args, &blk)
+          @listener.__send__("before_#{name}", *args)
+          returned = yield
+          @listener.__send__("after_#{name}", *args)
+
+          returned
+        end
+
+        def method_missing(meth, *args, &blk)
+          @delegate.__send__(meth, *args, &blk)
+        end
+      end # EventFiringBridge
+
+    end # Support
+  end # WebDriver
+end # Selenium