browserstack-webdriver 0.0.1

data/lib/selenium/webdriver/common/port_prober.rb

@@ -0,0 +1,42 @@
+module Selenium
+  module WebDriver
+    class PortProber
+      def self.above(port)
+        port += 1 until free? port
+        port
+      end
+
+      def self.random
+        # TODO: Avoid this
+        #
+        # (a) should pick a port that's guaranteed to be free on all interfaces
+        # (b) should pick a random port outside the ephemeral port range
+        #
+        server = TCPServer.new(Platform.localhost, 0)
+        port   = server.addr[1]
+        server.close
+
+        port
+      end
+
+      IGNORED_ERRORS = [Errno::EADDRNOTAVAIL]
+      IGNORED_ERRORS << Errno::EBADF if Platform.cygwin?
+
+      def self.free?(port)
+        Platform.interfaces.each do |host|
+          begin
+            TCPServer.new(host, port).close
+          rescue *IGNORED_ERRORS => ex
+            $stderr.puts "port prober could not bind to #{host}:#{port} (#{ex.message})" if $DEBUG
+            # ignored - some machines appear unable to bind to some of their interfaces
+          end
+        end
+
+        true
+      rescue SocketError, Errno::EADDRINUSE
+        false
+      end
+
+    end # PortProber
+  end # WebDriver
+end # Selenium

data/lib/selenium/webdriver/common/profile_helper.rb

@@ -0,0 +1,67 @@
+module Selenium
+  module WebDriver
+
+    #
+    # @api private
+    #
+    # Common methods for Chrome::Profile and Firefox::Profile
+    # Includers must implement #layout_on_disk
+    #
+
+    module ProfileHelper
+
+      def self.included(base)
+        base.extend ClassMethods
+      end
+
+      def as_json(opts = nil)
+        {'zip' => Zipper.zip(layout_on_disk)}
+      end
+
+      def to_json(*args)
+        WebDriver.json_dump as_json
+      end
+
+      private
+
+      def create_tmp_copy(directory)
+        tmp_directory = Dir.mktmpdir("webdriver-rb-profilecopy")
+
+        # TODO: must be a better way..
+        FileUtils.rm_rf tmp_directory
+        FileUtils.mkdir_p File.dirname(tmp_directory), :mode => 0700
+        FileUtils.cp_r directory, tmp_directory
+
+        tmp_directory
+      end
+
+      def verify_model(model)
+        return unless model
+
+        raise Errno::ENOENT, model unless File.exist?(model)
+        raise Errno::ENOTDIR, model unless File.directory?(model)
+
+        model
+      end
+
+      module ClassMethods
+        def from_json(json)
+          data = WebDriver.json_load(json).fetch('zip')
+
+          # can't use Tempfile here since it doesn't support File::BINARY mode on 1.8
+          # can't use Dir.mktmpdir(&blk) because of http://jira.codehaus.org/browse/JRUBY-4082
+          tmp_dir = Dir.mktmpdir
+          begin
+            zip_path = File.join(tmp_dir, "webdriver-profile-duplicate-#{json.hash}.zip")
+            File.open(zip_path, "wb") { |zip_file| zip_file << Base64.decode64(data) }
+
+            new Zipper.unzip(zip_path)
+          ensure
+            FileUtils.rm_rf tmp_dir
+          end
+        end
+      end # ClassMethods
+
+    end # ProfileHelper
+  end # WebDriver
+end # Selenium

data/lib/selenium/webdriver/common/proxy.rb

@@ -0,0 +1,149 @@
+module Selenium
+  module WebDriver
+    class Proxy
+      TYPES = {
+        :direct      => "DIRECT",     # Direct connection, no proxy (default on Windows).
+        :manual      => "MANUAL",     # Manual proxy settings (e.g., for httpProxy).
+        :pac         => "PAC",        # Proxy autoconfiguration from URL.
+        :auto_detect => "AUTODETECT", # Proxy autodetection (presumably with WPAD).
+        :system      => "SYSTEM"      # Use system settings (default on Linux).
+      }
+
+      attr_reader :type,
+                  :ftp,
+                  :http,
+                  :socks,
+                  :socks_username,
+                  :socks_password,
+                  :no_proxy,
+                  :pac,
+                  :ssl,
+                  :auto_detect
+
+      def initialize(opts = {})
+        opts = opts.dup
+
+        self.type           = opts.delete(:type) if opts.has_key? :type
+        self.ftp            = opts.delete(:ftp) if opts.has_key? :ftp
+        self.http           = opts.delete(:http) if opts.has_key? :http
+        self.no_proxy       = opts.delete(:no_proxy) if opts.has_key? :no_proxy
+        self.ssl            = opts.delete(:ssl) if opts.has_key? :ssl
+        self.pac            = opts.delete(:pac) if opts.has_key? :pac
+        self.auto_detect    = opts.delete(:auto_detect) if opts.has_key? :auto_detect
+        self.socks          = opts.delete(:socks) if opts.has_key? :socks
+        self.socks_username = opts.delete(:socks_username) if opts.has_key? :socks_username
+        self.socks_password = opts.delete(:socks_password) if opts.has_key? :socks_password
+
+        unless opts.empty?
+          raise ArgumentError, "unknown option#{'s' if opts.size != 1}: #{opts.inspect}"
+        end
+      end
+
+      def ==(other)
+        other.kind_of?(self.class) && as_json == other.as_json
+      end
+      alias_method :eql?, :==
+
+      def ftp=(value)
+        self.type = :manual
+        @ftp = value
+      end
+
+      def http=(value)
+        self.type = :manual
+        @http = value
+      end
+
+      def no_proxy=(value)
+        self.type = :manual
+        @no_proxy = value
+      end
+
+      def ssl=(value)
+        self.type = :manual
+        @ssl = value
+      end
+
+      def pac=(url)
+        self.type = :pac
+        @pac = url
+      end
+
+      def auto_detect=(bool)
+        self.type = :auto_detect
+        @auto_detect = bool
+      end
+
+      def socks=(value)
+        self.type = :manual
+        @socks = value
+      end
+
+      def socks_username=(value)
+        self.type = :manual
+        @socks_username = value
+      end
+
+      def socks_password=(value)
+        self.type = :manual
+        @socks_password = value
+      end
+
+      def type=(type)
+        unless TYPES.has_key? type
+          raise ArgumentError, "invalid proxy type: #{type.inspect}, expected one of #{TYPES.keys.inspect}"
+        end
+
+        if defined?(@type) && type != @type
+          raise ArgumentError, "incompatible proxy type #{type.inspect} (already set to #{@type.inspect})"
+        end
+
+        @type = type
+      end
+
+      def as_json(opts = nil)
+        json_result = {
+          "proxyType" => TYPES[type]
+        }
+
+        json_result["ftpProxy"]           = ftp if ftp
+        json_result["httpProxy"]          = http if http
+        json_result["noProxy"]            = no_proxy if no_proxy
+        json_result["proxyAutoconfigUrl"] = pac if pac
+        json_result["sslProxy"]           = ssl if ssl
+        json_result["autodetect"]         = auto_detect if auto_detect
+        json_result["socksProxy"]         = socks if socks
+        json_result["socksUsername"]      = socks_username if socks_username
+        json_result["socksPassword"]      = socks_password if socks_password
+
+        json_result if json_result.length > 1
+      end
+
+      def to_json(*args)
+        WebDriver.json_dump as_json
+      end
+
+      class << self
+        def json_create(data)
+          return if data['proxyType'] == 'UNSPECIFIED'
+
+          proxy = new
+
+          proxy.type           = data['proxyType'].downcase.to_sym if data.has_key? 'proxyType'
+          proxy.ftp            = data['ftpProxy'] if data.has_key? 'ftpProxy'
+          proxy.http           = data['httpProxy'] if data.has_key? 'httpProxy'
+          proxy.no_proxy       = data['noProxy'] if data.has_key? 'noProxy'
+          proxy.pac            = data['proxyAutoconfigUrl'] if data.has_key? 'proxyAutoconfigUrl'
+          proxy.ssl            = data['sslProxy'] if data.has_key? 'sslProxy'
+          proxy.auto_detect    = data['autodetect'] if data.has_key? 'autodetect'
+          proxy.socks          = data['socksProxy'] if data.has_key? 'socksProxy'
+          proxy.socks_username = data['socksUsername'] if data.has_key? 'socksUsername'
+          proxy.socks_password = data['socksPassword'] if data.has_key? 'socksPassword'
+
+          proxy
+        end
+      end # class << self
+
+    end # Proxy
+  end # WebDriver
+end # Selenium

data/lib/selenium/webdriver/common/search_context.rb

@@ -0,0 +1,92 @@
+module Selenium
+  module WebDriver
+    module SearchContext
+
+      # @api private
+      FINDERS = {
+        :class             => 'class name',
+        :class_name        => 'class name',
+        :css               => 'css selector',
+        :id                => 'id',
+        :link              => 'link text',
+        :link_text         => 'link text',
+        :name              => 'name',
+        :partial_link_text => 'partial link text',
+        :tag_name          => 'tag name',
+        :xpath             => 'xpath',
+      }
+
+      #
+      # Find the first element matching the given arguments.
+      #
+      # When using Element#find_element with :xpath, be aware that webdriver
+      # follows standard conventions: a search prefixed with "//" will search
+      # the entire document, not just the children of this current node. Use
+      # ".//" to limit your search to the children of the receiving Element.
+      #
+      # @param [:class, :class_name, :css, :id, :link_text, :link, :partial_link_text, :name, :tag_name, :xpath] how
+      # @param [String] what
+      # @return [Element]
+      #
+      # @raise [Error::NoSuchElementError] if the element doesn't exist
+      #
+      #
+
+      def find_element(*args)
+        how, what = extract_args(args)
+
+        unless by = FINDERS[how.to_sym]
+          raise ArgumentError, "cannot find element by #{how.inspect}"
+        end
+
+        bridge.find_element_by by, what.to_s, ref
+      end
+
+      #
+      # Find all elements matching the given arguments
+      #
+      # @see SearchContext#find_element
+      #
+      # @param [:class, :class_name, :css, :id, :link_text, :link, :partial_link_text, :name, :tag_name, :xpath] how
+      # @param [String] what
+      # @return [Array<Element>]
+      #
+
+      def find_elements(*args)
+        how, what = extract_args(args)
+
+        unless by = FINDERS[how.to_sym]
+          raise ArgumentError, "cannot find elements by #{how.inspect}"
+        end
+
+        bridge.find_elements_by by, what.to_s, ref
+      end
+
+      private
+
+      def extract_args(args)
+        case args.size
+        when 2
+          args
+        when 1
+          arg = args.first
+
+          unless arg.respond_to?(:shift)
+            raise ArgumentError, "expected #{arg.inspect}:#{arg.class} to respond to #shift"
+          end
+
+          # this will be a single-entry hash, so use #shift over #first or #[]
+          arr = arg.dup.shift
+          unless arr.size == 2
+            raise ArgumentError, "expected #{arr.inspect} to have 2 elements"
+          end
+
+          arr
+        else
+          raise ArgumentError, "wrong number of arguments (#{args.size} for 2)"
+        end
+      end
+
+    end # SearchContext
+  end # WebDriver
+end # Selenium

data/lib/selenium/webdriver/common/socket_poller.rb

@@ -0,0 +1,105 @@
+require 'selenium/webdriver/common/platform'
+require 'socket'
+
+module Selenium
+  module WebDriver
+    class SocketPoller
+
+      def initialize(host, port, timeout = 0, interval = 0.25)
+        @host     = host
+        @port     = Integer(port)
+        @timeout  = Float(timeout)
+        @interval = interval
+      end
+
+      #
+      # Returns true if the server is listening within the given timeout,
+      # false otherwise.
+      #
+      # @return [Boolean]
+      #
+
+      def connected?
+        with_timeout { listening? }
+      end
+
+      #
+      # Returns true if the server has stopped listening within the given timeout,
+      # false otherwise.
+      #
+      # @return [Boolean]
+      #
+
+      def closed?
+        with_timeout { not listening? }
+      end
+
+      private
+
+      CONNECT_TIMEOUT = 5
+
+      NOT_CONNECTED_ERRORS = [Errno::ECONNREFUSED, Errno::ENOTCONN, SocketError]
+      NOT_CONNECTED_ERRORS << Errno::EPERM if Platform.cygwin?
+
+      CONNECTED_ERRORS = [Errno::EISCONN]
+      CONNECTED_ERRORS << Errno::EINVAL if Platform.windows?
+
+      if Platform.jruby?
+        # we use a plain TCPSocket here since JRuby has issues select()ing on a connecting socket
+        # see http://jira.codehaus.org/browse/JRUBY-5165
+        def listening?
+          TCPSocket.new(@host, @port).close
+          true
+        rescue *NOT_CONNECTED_ERRORS
+          false
+        end
+      else
+        def listening?
+          addr     = Socket.getaddrinfo(@host, @port, Socket::AF_INET, Socket::SOCK_STREAM)
+          sock     = Socket.new(Socket::AF_INET, Socket::SOCK_STREAM, 0)
+          sockaddr = Socket.pack_sockaddr_in(@port, addr[0][3])
+
+          begin
+            sock.connect_nonblock sockaddr
+          rescue Errno::EINPROGRESS
+            if IO.select(nil, [sock], nil, CONNECT_TIMEOUT)
+              retry
+            else
+              raise Errno::ECONNREFUSED
+            end
+          rescue *CONNECTED_ERRORS
+            # yay!
+          end
+
+          sock.close
+          true
+        rescue *NOT_CONNECTED_ERRORS
+          sock.close if sock
+          $stderr.puts [@host, @port].inspect if $DEBUG
+          false
+        end
+      end
+
+      def with_timeout(&blk)
+        max_time = time_now + @timeout
+
+        (
+          return true if yield
+          wait
+        ) until time_now > max_time
+
+        false
+      end
+
+      def wait
+        sleep @interval
+      end
+
+      # for testability
+      def time_now
+        Time.now
+      end
+
+    end # SocketPoller
+  end # WebDriver
+end # Selenium