selenium-webdriver 4.1.0 → 4.23.0

data/lib/selenium/webdriver/common/interactions/key_input.rb

@@ -20,17 +20,18 @@
 module Selenium
   module WebDriver
     module Interactions
+      #
+      # Creates actions specific to Key Input devices
+      #
+      # @api private
+      #
+
       class KeyInput < InputDevice
         SUBTYPES = {down: :keyDown, up: :keyUp, pause: :pause}.freeze
 
-        def type
-          Interactions::KEY
-        end
-
-        def encode
-          return nil if no_actions?
-
-          {type: type, id: name, actions: @actions.map(&:encode)}
+        def initialize(name = nil)
+          super
+          @type = Interactions::KEY
         end
 
         def create_key_down(key)
@@ -41,25 +42,8 @@ module Selenium
           add_action(TypingInteraction.new(self, :up, key))
         end
 
-        class TypingInteraction < Interaction
-          attr_reader :type
-
-          def initialize(source, type, key)
-            super(source)
-            @type = assert_type(type)
-            @key = Keys.encode_key(key)
-          end
-
-          def assert_type(type)
-            raise TypeError, "#{type.inspect} is not a valid key subtype" unless KeyInput::SUBTYPES.key? type
-
-            KeyInput::SUBTYPES[type]
-          end
-
-          def encode
-            {type: @type, value: @key}
-          end
-        end # TypingInteraction
+        # Backward compatibility in case anyone called this directly
+        class TypingInteraction < Interactions::TypingInteraction; end
       end # KeyInput
     end # Interactions
   end # WebDriver

data/lib/selenium/webdriver/common/interactions/none_input.rb

@@ -20,15 +20,17 @@
 module Selenium
   module WebDriver
     module Interactions
-      class NoneInput < InputDevice
-        def type
-          Interactions::NONE
-        end
+      #
+      # Creates actions specific to null input source
+      # This is primarily used for adding pauses
+      #
+      # @api private
+      #
 
-        def encode
-          return nil if no_actions?
-
-          {type: type, id: name, actions: @actions.map(&:encode)}
+      class NoneInput < InputDevice
+        def initialize(name = nil)
+          super
+          @type = Interactions::NONE
         end
       end # NoneInput
     end # Interactions

data/lib/selenium/webdriver/common/interactions/pause.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+# Licensed to the Software Freedom Conservancy (SFC) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The SFC licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+module Selenium
+  module WebDriver
+    module Interactions
+      #
+      # Action to create a waiting period between actions
+      # Also used for synchronizing actions across devices
+      #
+      # @api private
+      #
+
+      class Pause < Interaction
+        def initialize(source, duration = nil)
+          super(source)
+          @duration = duration
+          @type = :pause
+        end
+
+        def assert_source(source)
+          raise TypeError, "#{source.type} is not a valid input type" unless source.is_a? InputDevice
+        end
+
+        def encode
+          output = {type: type}
+          output[:duration] = (@duration * 1000).to_i if @duration
+          output
+        end
+      end # Pause
+    end # Interactions
+  end # WebDriver
+end # Selenium

data/lib/selenium/webdriver/common/interactions/pointer_actions.rb

@@ -23,11 +23,12 @@ module Selenium
       attr_writer :default_move_duration
 
       #
-      # The overridable duration for movement used by methods in this module
+      # By default this is set to 250ms in the ActionBuilder constructor
+      # It can be overridden with default_move_duration=
       #
 
       def default_move_duration
-        @default_move_duration ||= 0.25 # 250 milliseconds
+        @default_move_duration ||= @duration / 1000.0 # convert ms to seconds
       end
 
       #
@@ -45,8 +46,8 @@ module Selenium
       # @return [ActionBuilder] A self reference.
       #
 
-      def pointer_down(button, device: nil)
-        button_action(button, action: :create_pointer_down, device: device)
+      def pointer_down(button = :left, device: nil, **opts)
+        button_action(button, :create_pointer_down, device: device, **opts)
       end
 
       #
@@ -62,21 +63,20 @@ module Selenium
       # @return [ActionBuilder] A self reference.
       #
 
-      def pointer_up(button, device: nil)
-        button_action(button, action: :create_pointer_up, device: device)
+      def pointer_up(button = :left, device: nil, **opts)
+        button_action(button, :create_pointer_up, device: device, **opts)
       end
 
       #
-      # Moves the mouse to the middle of the given element. The element is scrolled into
-      # view and its location is calculated using getBoundingClientRect.  Then the
-      # mouse is moved to optional offset coordinates from the element.
+      # Moves the pointer to the in-view center point of the given element.
+      # Then the pointer is moved to optional offset coordinates.
       #
-      # This is adapted to be backward compatible from non- actions.  calculates offset from the center point
-      # of the element
+      # The element is not scrolled into view.
+      # MoveTargetOutOfBoundsError will be raised if element with offset is outside the viewport
       #
-      # Note that when using offsets, both coordinates need to be passed.
+      # When using offsets, both coordinates need to be passed.
       #
-      # @example Scroll element into view and move the mouse to it
+      # @example Move the pointer to element
       #
       #   el = driver.find_element(id: "some_id")
       #   driver.action.move_to(el).perform
@@ -87,69 +87,59 @@ module Selenium
       #   driver.action.move_to(el, 100, 100).perform
       #
       # @param [Selenium::WebDriver::Element] element to move to.
-      # @param [Integer] right_by Optional offset from the top-left corner. A negative value means
-      #   coordinates to the left of the element.
-      # @param [Integer] down_by Optional offset from the top-left corner. A negative value means
-      #   coordinates above the element.
-      # @param [Symbol || String] device optional name of the PointerInput device to move.
+      # @param [Integer] right_by Optional offset from the in-view center of the
+      #   element. A negative value means coordinates to the left of the center.
+      # @param [Integer] down_by Optional offset from the in-view center of the
+      #   element. A negative value means coordinates to the top of the center.
       # @return [ActionBuilder] A self reference.
       #
 
-      def move_to(element, right_by = nil, down_by = nil, device: nil)
-        pointer = get_pointer(device)
-        # New actions offset is from center of element
-        if right_by || down_by
-          size = element.size
-          left_offset = (size[:width] / 2).to_i
-          top_offset = (size[:height] / 2).to_i
-          left = -left_offset + (right_by || 0)
-          top = -top_offset + (down_by || 0)
-        else
-          left = 0
-          top = 0
-        end
-        pointer.create_pointer_move(duration: default_move_duration,
-                                    x: left,
-                                    y: top,
-                                    element: element)
+      def move_to(element, right_by = nil, down_by = nil, **opts)
+        pointer = pointer_input(opts.delete(:device))
+        pointer.create_pointer_move(duration: opts.delete(:duration) || default_move_duration,
+                                    x: right_by || 0,
+                                    y: down_by || 0,
+                                    origin: element,
+                                    **opts)
         tick(pointer)
         self
       end
 
       #
-      # Moves the mouse from its current position by the given offset.
-      # If the coordinates provided are outside the viewport (the mouse will
-      # end up outside the browser window) then the viewport is scrolled to
-      # match.
+      # Moves the pointer from its current position by the given offset.
       #
-      # @example Move the mouse to a certain offset from its current position
+      # The viewport is not scrolled if the coordinates provided are outside the viewport.
+      # MoveTargetOutOfBoundsError will be raised if the offsets are outside the viewport
+      #
+      # @example Move the pointer to a certain offset from its current position
       #
       #    driver.action.move_by(100, 100).perform
       #
-      # @param [Integer] right_by horizontal offset. A negative value means moving the mouse left.
-      # @param [Integer] down_by vertical offset. A negative value means moving the mouse up.
+      # @param [Integer] right_by horizontal offset. A negative value means moving the pointer left.
+      # @param [Integer] down_by vertical offset. A negative value means moving the pointer up.
       # @param [Symbol || String] device optional name of the PointerInput device to move
       # @return [ActionBuilder] A self reference.
       # @raise [MoveTargetOutOfBoundsError] if the provided offset is outside the document's boundaries.
       #
 
-      def move_by(right_by, down_by, device: nil)
-        pointer = get_pointer(device)
-        pointer.create_pointer_move(duration: default_move_duration,
+      def move_by(right_by, down_by, device: nil, duration: default_move_duration, **opts)
+        pointer = pointer_input(device)
+        pointer.create_pointer_move(duration: duration,
                                     x: Integer(right_by),
                                     y: Integer(down_by),
-                                    origin: Interactions::PointerMove::POINTER)
+                                    origin: Interactions::PointerMove::POINTER,
+                                    **opts)
         tick(pointer)
         self
       end
 
       #
-      # Moves the mouse to a given location in the viewport.
-      # If the coordinates provided are outside the viewport (the mouse will
-      # end up outside the browser window) then the viewport is scrolled to
-      # match.
+      # Moves the pointer to a given location in the viewport.
+      #
+      # The viewport is not scrolled if the coordinates provided are outside the viewport.
+      # MoveTargetOutOfBoundsError will be raised if the offsets are outside the viewport
       #
-      # @example Move the mouse to a certain position in the viewport
+      # @example Move the pointer to a certain position in the viewport
       #
       #    driver.action.move_to_location(100, 100).perform
       #
@@ -160,12 +150,13 @@ module Selenium
       # @raise [MoveTargetOutOfBoundsError] if the provided x or y value is outside the document's boundaries.
       #
 
-      def move_to_location(x, y, device: nil)
-        pointer = get_pointer(device)
-        pointer.create_pointer_move(duration: default_move_duration,
+      def move_to_location(x, y, device: nil, duration: default_move_duration, **opts)
+        pointer = pointer_input(device)
+        pointer.create_pointer_move(duration: duration,
                                     x: Integer(x),
                                     y: Integer(y),
-                                    origin: Interactions::PointerMove::VIEWPORT)
+                                    origin: Interactions::PointerMove::VIEWPORT,
+                                    **opts)
         tick(pointer)
         self
       end
@@ -186,9 +177,9 @@ module Selenium
       # @return [ActionBuilder] A self reference.
       #
 
-      def click_and_hold(element = nil, device: nil)
+      def click_and_hold(element = nil, button: nil, device: nil)
         move_to(element, device: device) if element
-        pointer_down(:left, device: device)
+        pointer_down(button || :left, device: device)
         self
       end
 
@@ -205,8 +196,8 @@ module Selenium
       # @return [ActionBuilder] A self reference.
       #
 
-      def release(device: nil)
-        pointer_up(:left, device: device)
+      def release(button: nil, device: nil)
+        pointer_up(button || :left, device: device)
         self
       end
 
@@ -232,10 +223,10 @@ module Selenium
       # @return [ActionBuilder] A self reference.
       #
 
-      def click(element = nil, device: nil)
+      def click(element = nil, button: nil, device: nil)
         move_to(element, device: device) if element
-        pointer_down(:left, device: device)
-        pointer_up(:left, device: device)
+        pointer_down(button || :left, device: device)
+        pointer_up(button || :left, device: device)
         self
       end
 
@@ -290,10 +281,7 @@ module Selenium
       #
 
       def context_click(element = nil, device: nil)
-        move_to(element, device: device) if element
-        pointer_down(:right, device: device)
-        pointer_up(:right, device: device)
-        self
+        click(element, button: :right, device: device)
       end
 
       #
@@ -348,15 +336,15 @@ module Selenium
 
       private
 
-      def button_action(button, action: nil, device: nil)
-        pointer = get_pointer(device)
-        pointer.send(action, button)
+      def button_action(button, action, device: nil, **opts)
+        pointer = pointer_input(device)
+        pointer.send(action, button, **opts)
         tick(pointer)
         self
       end
 
-      def get_pointer(device = nil)
-        get_device(device) || pointer_inputs.first
+      def pointer_input(name = nil)
+        device(name: name, type: Interactions::POINTER) || add_pointer_input(:mouse, 'mouse')
       end
     end # PointerActions
   end # WebDriver

data/lib/selenium/webdriver/common/{driver_extensions/has_network_connection.rb → interactions/pointer_cancel.rb}

@@ -17,21 +17,29 @@
 # specific language governing permissions and limitations
 # under the License.
 
-# TODO: Deprecated; Delete after 4.0 release
 module Selenium
   module WebDriver
-    module DriverExtensions
-      module HasNetworkConnection
-        def network_connection_type
-          raise Error::UnsupportedOperationError,
-                'The W3C standard does not currently support getting network connection'
+    module Interactions
+      #
+      # Action to cancel any other Pointer Action.
+      #
+      # @api private
+      #
+
+      class PointerCancel < Interaction
+        def initialize(source)
+          super
+          @type = :pointerCancel
+        end
+
+        def assert_source(source)
+          raise TypeError, "#{source.type} is not a valid input type" unless source.is_a? PointerInput
         end
 
-        def network_connection_type=(*)
-          raise Error::UnsupportedOperationError,
-                'The W3C standard does not currently support setting network connection'
+        def encode
+          {type: type}
         end
-      end # HasNetworkConnection
-    end # DriverExtensions
+      end # PointerCancel
+    end # Interactions
   end # WebDriver
 end # Selenium

data/lib/selenium/webdriver/common/interactions/pointer_event_properties.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+# Licensed to the Software Freedom Conservancy (SFC) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The SFC licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+module Selenium
+  module WebDriver
+    module Interactions
+      module PointerEventProperties
+        VALID = {width: {'width' => {min: 0.0}},
+                 height: {'height' => {min: 0.0}},
+                 pressure: {'pressure' => {min: 0.0, max: 1.0}},
+                 tangential_pressure: {'tangentialPressure' => {min: -1.0, max: 1.0}},
+                 tilt_x: {'tiltX' => {min: -90, max: 90}},
+                 tilt_y: {'tiltY' => {min: -90, max: 90}},
+                 twist: {'twist' => {min: 0, max: 359}},
+                 altitude_angle: {'altitudeAngle' => {min: 0.0, max: (Math::PI / 2)}},
+                 azimuth_angle: {'azimuthAngle' => {min: 0.0, max: (Math::PI * 2)}}}.freeze
+
+        def process_opts
+          raise ArgumentError, "Unknown options found: #{@opts.inspect}" unless (@opts.keys - VALID.keys).empty?
+
+          VALID.each_with_object({}) do |(key, val), hash|
+            next unless @opts.key?(key)
+
+            name = val.keys.first
+            values = val.values.first
+            hash[name] = assert_number(@opts[key], values[:min], values[:max])
+          end
+        end
+
+        private
+
+        def assert_number(num, min, max = nil)
+          return if num.nil?
+
+          klass = min.is_a?(Integer) ? Integer : Numeric
+          raise TypeError, "#{num} is not a #{klass}" unless num.is_a?(klass)
+
+          raise ArgumentError, "#{num} is not greater than or equal to #{min}" if num < min
+
+          raise ArgumentError, "#{num} is not less than or equal to #{max}" if max && num > max
+
+          num
+        end
+      end # PointerEventProperties
+    end # Interactions
+  end # WebDriver
+end # Selenium

data/lib/selenium/webdriver/common/interactions/pointer_input.rb

@@ -20,6 +20,12 @@
 module Selenium
   module WebDriver
     module Interactions
+      #
+      # Creates actions specific to Pointer Input devices
+      #
+      # @api private
+      #
+
       class PointerInput < InputDevice
         KIND = {mouse: :mouse, pen: :pen, touch: :touch}.freeze
 
@@ -28,17 +34,12 @@ module Selenium
         def initialize(kind, name: nil)
           super(name)
           @kind = assert_kind(kind)
-        end
-
-        def type
-          Interactions::POINTER
+          @type = Interactions::POINTER
         end
 
         def encode
-          return nil if no_actions?
-
-          output = {type: type, id: name, actions: @actions.map(&:encode)}
-          output[:parameters] = {pointerType: kind}
+          output = super
+          output[:parameters] = {pointerType: kind} if output
           output
         end
 
@@ -48,92 +49,22 @@ module Selenium
           KIND[pointer]
         end
 
-        def create_pointer_move(duration: 0, x: 0, y: 0, element: nil, origin: nil)
-          add_action(PointerMove.new(self, duration, x, y, element: element, origin: origin))
+        def create_pointer_move(duration: 0, x: 0, y: 0, origin: nil, **opts)
+          add_action(PointerMove.new(self, duration, x, y, origin: origin, **opts))
         end
 
-        def create_pointer_down(button)
-          add_action(PointerPress.new(self, :down, button))
+        def create_pointer_down(button, **opts)
+          add_action(PointerPress.new(self, :down, button, **opts))
         end
 
-        def create_pointer_up(button)
-          add_action(PointerPress.new(self, :up, button))
+        def create_pointer_up(button, **opts)
+          add_action(PointerPress.new(self, :up, button, **opts))
         end
 
         def create_pointer_cancel
           add_action(PointerCancel.new(self))
         end
       end # PointerInput
-
-      class PointerPress < Interaction
-        BUTTONS = {left: 0, middle: 1, right: 2}.freeze
-        DIRECTIONS = {down: :pointerDown, up: :pointerUp}.freeze
-
-        def initialize(source, direction, button)
-          super(source)
-          @direction = assert_direction(direction)
-          @button = assert_button(button)
-        end
-
-        def type
-          @direction
-        end
-
-        def assert_button(button)
-          if button.is_a? Symbol
-            raise TypeError, "#{button.inspect} is not a valid button!" unless BUTTONS.key? button
-
-            button = BUTTONS[button]
-          end
-          raise ArgumentError, 'Button number cannot be negative!' unless button >= 0
-
-          button
-        end
-
-        def assert_direction(direction)
-          raise TypeError, "#{direction.inspect} is not a valid button direction" unless DIRECTIONS.key? direction
-
-          DIRECTIONS[direction]
-        end
-
-        def encode
-          {type: type, button: @button}
-        end
-      end # PointerPress
-
-      class PointerMove < Interaction
-        VIEWPORT = :viewport
-        POINTER = :pointer
-        ORIGINS = [VIEWPORT, POINTER].freeze
-
-        def initialize(source, duration, x, y, element: nil, origin: nil)
-          super(source)
-          @duration = duration * 1000
-          @x_offset = x
-          @y_offset = y
-          @origin = element || origin
-        end
-
-        def type
-          :pointerMove
-        end
-
-        def encode
-          output = {type: type, duration: @duration.to_i, x: @x_offset, y: @y_offset}
-          output[:origin] = @origin
-          output
-        end
-      end # Move
-
-      class PointerCancel < Interaction
-        def type
-          :pointerCancel
-        end
-
-        def encode
-          {type: type}
-        end
-      end # Cancel
     end # Interactions
   end # WebDriver
 end # Selenium

data/lib/selenium/webdriver/common/interactions/pointer_move.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+# Licensed to the Software Freedom Conservancy (SFC) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The SFC licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+module Selenium
+  module WebDriver
+    module Interactions
+      #
+      # Action related to moving the pointer.
+      #
+      # @api private
+      #
+
+      class PointerMove < Interaction
+        include PointerEventProperties
+
+        VIEWPORT = :viewport
+        POINTER = :pointer
+        ORIGINS = [VIEWPORT, POINTER].freeze
+
+        def initialize(source, duration, x, y, **opts)
+          super(source)
+          @duration = duration * 1000
+          @x_offset = x
+          @y_offset = y
+          @origin = opts.delete(:element) || opts.delete(:origin) || :viewport
+          @type = :pointerMove
+          @opts = opts
+        end
+
+        def assert_source(source)
+          raise TypeError, "#{source.type} is not a valid input type" unless source.is_a? PointerInput
+        end
+
+        def encode
+          process_opts.merge('type' => type.to_s,
+                             'duration' => @duration.to_i,
+                             'x' => @x_offset,
+                             'y' => @y_offset,
+                             'origin' => @origin)
+        end
+      end # PointerMove
+    end # Interactions
+  end # WebDriver
+end # Selenium