browserstack-webdriver 0.0.1

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,38 @@
+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
+
+      #
+      # Sets the amount of time to wait for a page load to complete before throwing an error.
+      # If the timeout is negative, page loads can be indefinite.
+      #
+
+      def page_load=(seconds)
+        @bridge.setTimeout 'page load', Integer(seconds * 1000)
+      end
+
+    end # Timeouts
+  end # WebDriver
+end # Selenium

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

@@ -0,0 +1,64 @@
+module Selenium
+  module WebDriver
+    class TouchActionBuilder < ActionBuilder
+
+      #
+      # @api private
+      #
+
+      def initialize(mouse, keyboard, touch_screen)
+        super(mouse, keyboard)
+        @devices[:touch_screen] = touch_screen
+      end
+
+      def scroll(*args)
+        unless [2,3].include? args.size
+          raise ArgumentError, "wrong number of arguments, expected 2..3, got #{args.size}"
+        end
+
+        @actions << [:touch_screen, :scroll, args]
+        self
+      end
+
+      def flick(*args)
+        unless [2,4].include? args.size
+          raise ArgumentError, "wrong number of arguments, expected 2 or 4, got #{args.size}"
+        end
+
+        @actions << [:touch_screen, :flick, args]
+        self
+      end
+
+      def single_tap(element)
+        @actions << [:touch_screen, :single_tap, [element]]
+        self
+      end
+
+      def double_tap(element)
+        @actions << [:touch_screen, :double_tap, [element]]
+        self
+      end
+
+      def long_press(element)
+        @actions << [:touch_screen, :long_press, [element]]
+        self
+      end
+
+      def down(x, y = nil)
+        @actions << [:touch_screen, :down, [x, y]]
+        self
+      end
+
+      def up(x, y = nil)
+        @actions << [:touch_screen, :up, [x, y]]
+        self
+      end
+
+      def move(x, y = nil)
+        @actions << [:touch_screen, :move, [x, y]]
+        self
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,105 @@
+module Selenium
+  module WebDriver
+    class TouchScreen
+      FLICK_SPEED = { :normal => 0, :fast => 1}
+
+
+      #
+      # @api private
+      #
+
+      def initialize(bridge)
+        @bridge = bridge
+      end
+
+      def single_tap(element)
+        assert_element element
+        @bridge.touchSingleTap element.ref
+      end
+
+      def double_tap(element)
+        assert_element element
+        @bridge.touchDoubleTap element.ref
+      end
+
+      def long_press(element)
+        assert_element element
+        @bridge.touchLongPress element.ref
+      end
+
+      def down(x, y = nil)
+        x, y = coords_from x, y
+        @bridge.touchDown x, y
+      end
+
+      def up(x, y = nil)
+        x, y = coords_from x, y
+        @bridge.touchUp x, y
+      end
+
+      def move(x, y = nil)
+        x, y = coords_from x, y
+        @bridge.touchMove x, y
+      end
+
+      def scroll(*args)
+        case args.size
+        when 2
+          x_offset, y_offset = args
+          @bridge.touchScroll nil, Integer(x_offset), Integer(y_offset)
+        when 3
+          element, x_offset, y_offset = args
+          assert_element element
+          @bridge.touchScroll element.ref, Integer(x_offset), Integer(y_offset)
+        else
+          raise ArgumentError, "wrong number of arguments, expected 2..3, got #{args.size}"
+        end
+      end
+
+      def flick(*args)
+        case args.size
+        when 2
+          x_speed, y_speed = args
+          @bridge.touchFlick Integer(x_speed), Integer(y_speed)
+        when 4
+          element, xoffset, yoffset, speed = args
+
+          assert_element element
+          flick_speed = FLICK_SPEED[speed.to_sym]
+
+          unless flick_speed
+            raise ArgumentError, "expected one of #{FLICK_SPEED.keys.inspect}, got #{speed.inspect}"
+          end
+
+          @bridge.touchElementFlick element.ref, Integer(xoffset), Integer(yoffset), flick_speed
+        else
+          raise ArgumentError, "wrong number of arguments, expected 2 or 4, got #{args.size}"
+        end
+
+      end
+
+      private
+
+      def coords_from(x, y)
+        if y.nil?
+          point = x
+
+          unless point.respond_to?(:x) && point.respond_to?(:y)
+            raise ArgumentError, "expected #{point.inspect} to respond to :x and :y"
+          end
+
+          x, y = point.x, point.y
+        end
+
+        [Integer(x), Integer(y)]
+      end
+
+      def assert_element(element)
+        unless element.kind_of? Element
+          raise TypeError, "expected #{Element}, got #{element.inspect}:#{element.class}"
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+module Selenium
+  module WebDriver
+    class Wait
+
+      DEFAULT_TIMEOUT  = 5
+      DEFAULT_INTERVAL = 0.2
+
+      #
+      # 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.2) Seconds to sleep between polls.
+      # @option opts [String] :message Exception mesage if timed out.
+      # @option opts [Array, Exception] :ignore Exceptions to ignore while polling (default: Error::NoSuchElementError)
+      #
+
+      def initialize(opts = {})
+        @timeout  = opts.fetch(:timeout, DEFAULT_TIMEOUT)
+        @interval = opts.fetch(:interval, DEFAULT_INTERVAL)
+        @message  = opts[:message]
+        @ignored  = Array(opts[:ignore] || Error::NoSuchElementError)
+      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 *@ignored => 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,104 @@
+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
+
+      #
+      # Maximize the current window
+      #
+
+      def maximize
+        @bridge.maximizeWindow
+      end
+
+
+    end
+  end
+end