bbc-selenium-webdriver 1.17.0

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

@@ -0,0 +1,100 @@
+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
+
+    end # SocketPoller
+  end # WebDriver
+end # Selenium

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

@@ -0,0 +1,81 @@
+module Selenium
+  module WebDriver
+    class TargetLocator
+
+      #
+      # @api private
+      #
+
+      def initialize(bridge)
+        @bridge = bridge
+      end
+
+      #
+      # switch to the frame with the given id
+      #
+
+      def frame(id)
+        @bridge.switchToFrame id
+      end
+
+      #
+      # switch to the given window handle
+      #
+      # If given a block, this method will switch back to the original window after
+      # block execution.
+      #
+      # @param id
+      #   A window handle, obtained through Driver#window_handles
+      #
+
+      def window(id)
+        if block_given?
+          original = @bridge.getCurrentWindowHandle
+          @bridge.switchToWindow id
+
+          begin
+            returned = yield
+          ensure
+            current_handles = @bridge.getWindowHandles
+
+            if current_handles.size == 1
+              original = current_handles.shift
+            end
+
+            @bridge.switchToWindow original
+            returned
+          end
+        else
+          @bridge.switchToWindow id
+        end
+      end
+
+      #
+      # get the active element
+      #
+      # @return [WebDriver::Element]
+      #
+
+      def active_element
+        @bridge.switchToActiveElement
+      end
+
+      #
+      # selects either the first frame on the page, or the main document when a page contains iframes.
+      #
+
+      def default_content
+        @bridge.switchToDefaultContent
+      end
+
+      #
+      # switches to the currently active modal dialog for this particular driver instance
+      #
+
+      def alert
+        Alert.new(@bridge)
+      end
+
+    end # TargetLocator
+  end # WebDriver
+end  # Selenium

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

@@ -0,0 +1,29 @@
+module Selenium
+  module WebDriver
+    class Timeouts
+
+      def initialize(bridge)
+        @bridge = bridge
+      end
+
+      #
+      # Set the amount of time the driver should wait when searching for elements.
+      #
+
+      def implicit_wait=(seconds)
+        @bridge.setImplicitWaitTimeout Integer(seconds * 1000)
+      end
+
+      #
+      # Sets the amount of time to wait for an asynchronous script to finish
+      # execution before throwing an error. If the timeout is negative, then the
+      # script will be allowed to run indefinitely.
+      #
+
+      def script_timeout=(seconds)
+        @bridge.setScriptTimeout Integer(seconds * 1000)
+      end
+
+    end # Timeouts
+  end # WebDriver
+end # Selenium

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

@@ -0,0 +1,60 @@
+module Selenium
+  module WebDriver
+    class Wait
+
+      DEFAULT_TIMEOUT  = 5
+      DEFAULT_INTERVAL = 0.5
+
+      #
+      # Create a new Wait instance
+      #
+      # @param [Hash] opts Options for this instance
+      # @option opts [Numeric] :timeout (5) Seconds to wait before timing out.
+      # @option opts [Numeric] :interval (0.5) Seconds to sleep between polls.
+      # @option opts [String] :message Exception mesage if timed out.
+
+      def initialize(opts = {})
+        @timeout  = opts.fetch(:timeout, DEFAULT_TIMEOUT)
+        @interval = opts.fetch(:interval, DEFAULT_INTERVAL)
+        @message  = opts[:message]
+      end
+
+
+      #
+      # Wait until the given block returns a true value.
+      #
+      # @raise [Error::TimeOutError]
+      # @return [Object] the result of the block
+      #
+
+      def until(&blk)
+        end_time = Time.now + @timeout
+        last_error = nil
+
+        until Time.now > end_time
+          begin
+            result = yield
+            return result if result
+          rescue Error::NoSuchElementError => last_error
+            # swallowed
+          end
+
+          sleep @interval
+        end
+
+
+        if @message
+          msg = @message.dup
+        else
+          msg = "timed out after #{@timeout} seconds"
+        end
+
+        msg << " (#{last_error.message})}" if last_error
+
+        raise Error::TimeOutError, msg
+      end
+
+    end # Wait
+  end # WebDriver
+end # Selenium
+

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

@@ -0,0 +1,96 @@
+module Selenium
+  module WebDriver
+
+    #
+    # @api beta This API may be changed or removed in a future release.
+    #
+
+    class Window
+
+      #
+      # @api private
+      #
+
+      def initialize(bridge)
+        @bridge = bridge
+      end
+
+      #
+      # Resize the current window to the given dimension.
+      #
+      # @param [Selenium::WebDriver::Dimension, #width and #height] dimension The new size.
+      #
+
+      def size=(dimension)
+        unless dimension.respond_to?(:width) && dimension.respond_to?(:height)
+          raise ArgumentError, "expected #{dimension.inspect}:#{dimension.class}" +
+                                " to respond to #width and #height"
+        end
+
+        @bridge.setWindowSize dimension.width, dimension.height
+      end
+
+      #
+      # Get the size of the current window.
+      #
+      # @return [Selenium::WebDriver::Dimension] The size.
+      #
+
+      def size
+        @bridge.getWindowSize
+      end
+
+      #
+      # Move the current window to the given position.
+      #
+      # @param [Selenium::WebDriver::Point, #x and #y] point The new position.
+      #
+
+      def position=(point)
+        unless point.respond_to?(:x) && point.respond_to?(:y)
+          raise ArgumentError, "expected #{point.inspect}:#{point.class}" +
+                                " to respond to #x and #y"
+        end
+
+        @bridge.setWindowPosition point.x, point.y
+      end
+
+      #
+      # Get the position of the current window.
+      #
+      # @return [Selenium::WebDriver::Point] The position.
+      #
+
+      def position
+        @bridge.getWindowPosition
+      end
+
+      #
+      # Equivalent to #size=, but accepts width and height arguments.
+      #
+      # @example Maximize the window.
+      #
+      #    max_width, max_height = driver.execute_script("return [window.screen.availWidth, window.screen.availHeight];")
+      #    driver.manage.window.resize_to(max_width, max_height)
+      #
+
+      def resize_to(width, height)
+        @bridge.setWindowSize Integer(width), Integer(height)
+      end
+
+      #
+      # Equivalent to #position=, but accepts x and y arguments.
+      #
+      # @example
+      #
+      #   driver.manage.window.move_to(300, 400)
+      #
+
+      def move_to(x, y)
+        @bridge.setWindowPosition Integer(x), Integer(y)
+      end
+
+
+    end
+  end
+end

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

@@ -0,0 +1,82 @@
+require 'zip/zip'
+require 'tempfile'
+require 'find'
+
+module Selenium
+  module WebDriver
+    #
+    # @api private
+    #
+
+    module Zipper
+
+      EXTENSIONS = %w[.zip .xpi]
+
+      class << self
+
+        def unzip(path)
+          destination = Dir.mktmpdir("unzip")
+          FileReaper << destination
+
+          Zip::ZipFile.open(path) do |zip|
+            zip.each do |entry|
+              to      = File.join(destination, entry.name)
+              dirname = File.dirname(to)
+
+              FileUtils.mkdir_p dirname unless File.exist? dirname
+              zip.extract(entry, to)
+            end
+          end
+
+          destination
+        end
+
+        def zip(path)
+          with_tmp_zip do |zip|
+            ::Find.find(path) do |file|
+              unless File.directory?(file)
+                add_zip_entry zip, file, file.sub("#{path}/", '')
+              end
+            end
+
+            zip.commit
+            File.open(zip.name, "rb") { |io| Base64.strict_encode64 io.read }
+          end
+        end
+
+        def zip_file(path)
+          with_tmp_zip do |zip|
+            add_zip_entry zip, path, File.basename(path)
+
+            zip.commit
+            File.open(zip.name, "rb") { |io| Base64.strict_encode64 io.read }
+          end
+        end
+
+        private
+
+        def with_tmp_zip(&blk)
+          # 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
+          zip_path = File.join(tmp_dir, "webdriver-zip")
+
+          begin
+            Zip::ZipFile.open(zip_path, Zip::ZipFile::CREATE, &blk)
+          ensure
+            FileUtils.rm_rf tmp_dir
+            FileUtils.rm_rf zip_path
+          end
+        end
+
+        def add_zip_entry(zip, file, entry_name)
+          entry = Zip::ZipEntry.new(zip.name, entry_name)
+          entry.follow_symlinks = true
+
+          zip.add entry, file
+        end
+
+      end
+    end # Zipper
+  end # WebDriver
+end # Selenium