cuprite 0.14.1 → 0.14.2

data/lib/capybara/cuprite/node.rb

@@ -0,0 +1,285 @@
+# frozen_string_literal: true
+
+require "forwardable"
+
+module Capybara
+  module Cuprite
+    class Node < Capybara::Driver::Node
+      attr_reader :node
+
+      extend Forwardable
+
+      delegate %i[description] => :node
+      delegate %i[browser] => :driver
+
+      def initialize(driver, node)
+        super(driver, self)
+        @node = node
+      end
+
+      def command(name, *args)
+        browser.send(name, node, *args)
+      rescue Ferrum::NodeNotFoundError => e
+        raise ObsoleteNode.new(self, e.response)
+      rescue Ferrum::BrowserError => e
+        case e.message
+        when "Cuprite.MouseEventFailed"
+          raise MouseEventFailed.new(self, e.response)
+        else
+          raise
+        end
+      end
+
+      def parents
+        command(:parents).map do |parent|
+          self.class.new(driver, parent)
+        end
+      end
+
+      def find_xpath(selector)
+        find(:xpath, selector)
+      end
+
+      def find_css(selector)
+        find(:css, selector)
+      end
+
+      def find(method, selector)
+        command(:find_within, method, selector).map do |node|
+          self.class.new(driver, node)
+        end
+      end
+
+      def all_text
+        filter_text(command(:all_text))
+      end
+
+      def visible_text
+        command(:visible_text).to_s
+                              .gsub(/\A[[:space:]&&[^\u00a0]]+/, "")
+                              .gsub(/[[:space:]&&[^\u00a0]]+\z/, "")
+                              .gsub(/\n+/, "\n")
+                              .tr("\u00a0", " ")
+      end
+
+      def property(name)
+        command(:property, name)
+      end
+
+      def [](name)
+        # Although the attribute matters, the property is consistent. Return that in
+        # preference to the attribute for links and images.
+        if (tag_name == "img" && name == "src") ||
+           (tag_name == "a" && name == "href")
+          # if attribute exists get the property
+          return command(:attribute, name) && command(:property, name)
+        end
+
+        value = property(name)
+        value = command(:attribute, name) if value.nil? || value.is_a?(Hash)
+
+        value
+      end
+
+      def attributes
+        command(:attributes)
+      end
+
+      def value
+        command(:value)
+      end
+
+      def set(value, options = {})
+        warn "Options passed to Node#set but Cuprite doesn't currently support any - ignoring" unless options.empty?
+
+        if tag_name == "input"
+          case self[:type]
+          when "radio"
+            click
+          when "checkbox"
+            click if value != checked?
+          when "file"
+            files = value.respond_to?(:to_ary) ? value.to_ary.map(&:to_s) : value.to_s
+            command(:select_file, files)
+          when "color"
+            node.evaluate("this.setAttribute('value', '#{value}')")
+          else
+            command(:set, value.to_s)
+          end
+        elsif tag_name == "textarea"
+          command(:set, value.to_s)
+        elsif self[:isContentEditable]
+          command(:delete_text)
+          send_keys(value.to_s)
+        end
+      end
+
+      def select_option
+        command(:select, true)
+      end
+
+      def unselect_option
+        command(:select, false) ||
+          raise(Capybara::UnselectNotAllowed, "Cannot unselect option from single select box.")
+      end
+
+      def tag_name
+        @tag_name ||= description["nodeName"].downcase
+      end
+
+      def visible?
+        command(:visible?)
+      end
+
+      def checked?
+        self[:checked]
+      end
+
+      def selected?
+        !!self[:selected]
+      end
+
+      def disabled?
+        command(:disabled?)
+      end
+
+      def click(keys = [], **options)
+        prepare_and_click(:left, __method__, keys, options)
+      end
+
+      def right_click(keys = [], **options)
+        prepare_and_click(:right, __method__, keys, options)
+      end
+
+      def double_click(keys = [], **options)
+        prepare_and_click(:double, __method__, keys, options)
+      end
+
+      def hover
+        command(:hover)
+      end
+
+      def drag_to(other)
+        command(:drag, other.node)
+      end
+
+      def drag_by(x, y)
+        command(:drag_by, x, y)
+      end
+
+      def trigger(event)
+        command(:trigger, event)
+      end
+
+      def scroll_to(element, location, position = nil)
+        if element.is_a?(Node)
+          scroll_element_to_location(element, location)
+        elsif location.is_a?(Symbol)
+          scroll_to_location(location)
+        else
+          scroll_to_coords(*position)
+        end
+        self
+      end
+
+      def scroll_by(x, y)
+        driver.execute_script <<~JS, self, x, y
+          var el = arguments[0];
+          if (el.scrollBy){
+            el.scrollBy(arguments[1], arguments[2]);
+          } else {
+            el.scrollTop = el.scrollTop + arguments[2];
+            el.scrollLeft = el.scrollLeft + arguments[1];
+          }
+        JS
+      end
+
+      def ==(other)
+        node == other.native.node
+      end
+
+      def send_keys(*keys)
+        command(:send_keys, keys)
+      end
+      alias send_key send_keys
+
+      def path
+        command(:path)
+      end
+
+      def inspect
+        %(#<#{self.class} @node=#{@node.inspect}>)
+      end
+
+      # @api private
+      def to_json(*)
+        JSON.generate(as_json)
+      end
+
+      # @api private
+      def as_json(*)
+        # FIXME: Where is this method used and why attr is called id?
+        { ELEMENT: { node: node, id: node.node_id } }
+      end
+
+      private
+
+      def prepare_and_click(mode, name, keys, options)
+        delay = options[:delay].to_i
+        x, y = options.values_at(:x, :y)
+        offset = { x: x, y: y, position: options[:offset] || :top }
+        command(:before_click, name, keys, offset)
+        node.click(mode: mode, keys: keys, offset: offset, delay: delay)
+      end
+
+      def filter_text(text)
+        text.gsub(/[\u200b\u200e\u200f]/, "")
+            .gsub(/[\ \n\f\t\v\u2028\u2029]+/, " ")
+            .gsub(/\A[[:space:]&&[^\u00a0]]+/, "")
+            .gsub(/[[:space:]&&[^\u00a0]]+\z/, "")
+            .tr("\u00a0", " ")
+      end
+
+      def scroll_element_to_location(element, location)
+        scroll_opts = case location
+                      when :top
+                        "true"
+                      when :bottom
+                        "false"
+                      when :center
+                        "{behavior: 'instant', block: 'center'}"
+                      else
+                        raise ArgumentError, "Invalid scroll_to location: #{location}"
+                      end
+        driver.execute_script <<~JS, element
+          arguments[0].scrollIntoView(#{scroll_opts})
+        JS
+      end
+
+      def scroll_to_location(location)
+        height = { top: "0",
+                   bottom: "arguments[0].scrollHeight",
+                   center: "(arguments[0].scrollHeight - arguments[0].clientHeight)/2" }
+
+        driver.execute_script <<~JS, self
+          if (arguments[0].scrollTo){
+            arguments[0].scrollTo(0, #{height[location]});
+          } else {
+            arguments[0].scrollTop = #{height[location]};
+          }
+        JS
+      end
+
+      def scroll_to_coords(x, y)
+        driver.execute_script <<~JS, self, x, y
+          if (arguments[0].scrollTo){
+            arguments[0].scrollTo(arguments[1], arguments[2]);
+          } else {
+            arguments[0].scrollTop = arguments[2];
+            arguments[0].scrollLeft = arguments[1];
+          }
+        JS
+      end
+    end
+  end
+end

data/lib/capybara/cuprite/page.rb

@@ -0,0 +1,205 @@
+# frozen_string_literal: true
+
+require "forwardable"
+
+module Capybara
+  module Cuprite
+    class Page < Ferrum::Page
+      MODAL_WAIT = ENV.fetch("CUPRITE_MODAL_WAIT", 0.05).to_f
+      TRIGGER_CLICK_WAIT = ENV.fetch("CUPRITE_TRIGGER_CLICK_WAIT", 0.1).to_f
+
+      extend Forwardable
+      delegate %i[at_css at_xpath css xpath
+                  current_url current_title body execution_id
+                  evaluate evaluate_on evaluate_async execute] => :active_frame
+
+      def initialize(*args)
+        @frame_stack = []
+        @accept_modal = []
+        @modal_messages = []
+        super
+      end
+
+      def set(node, value)
+        object_id = command("DOM.resolveNode", nodeId: node.node_id).dig("object", "objectId")
+        evaluate("_cuprite.set(arguments[0], arguments[1])", { "objectId" => object_id }, value)
+      end
+
+      def select(node, value)
+        evaluate_on(node: node, expression: "_cuprite.select(this, #{value})")
+      end
+
+      def trigger(node, event)
+        options = {}
+        options.merge!(wait: TRIGGER_CLICK_WAIT) if event.to_s == "click" && TRIGGER_CLICK_WAIT.positive?
+        evaluate_on(node: node, expression: %(_cuprite.trigger(this, "#{event}")), **options)
+      end
+
+      def hover(node)
+        evaluate_on(node: node, expression: "_cuprite.scrollIntoViewport(this)")
+        x, y = find_position(node)
+        command("Input.dispatchMouseEvent", type: "mouseMoved", x: x, y: y)
+      end
+
+      def send_keys(node, keys)
+        unless evaluate_on(node: node, expression: %(_cuprite.containsSelection(this)))
+          before_click(node, "click")
+          node.click(mode: :left, keys: keys)
+        end
+
+        keyboard.type(keys)
+      end
+
+      def accept_confirm
+        @accept_modal << true
+      end
+
+      def dismiss_confirm
+        @accept_modal << false
+      end
+
+      def accept_prompt(modal_response)
+        @accept_modal << true
+        @modal_response = modal_response
+      end
+
+      def dismiss_prompt
+        @accept_modal << false
+      end
+
+      def find_modal(options)
+        start = Ferrum::Utils::ElapsedTime.monotonic_time
+        timeout = options.fetch(:wait, browser.timeout)
+        expect_text = options[:text]
+        expect_regexp = expect_text.is_a?(Regexp) ? expect_text : Regexp.escape(expect_text.to_s)
+        not_found_msg = "Unable to find modal dialog"
+        not_found_msg += " with #{expect_text}" if expect_text
+
+        begin
+          modal_text = @modal_messages.shift
+          raise Capybara::ModalNotFound if modal_text.nil? || (expect_text && !modal_text.match(expect_regexp))
+        rescue Capybara::ModalNotFound => e
+          raise e, not_found_msg if Ferrum::Utils::ElapsedTime.timeout?(start, timeout)
+
+          sleep(MODAL_WAIT)
+          retry
+        end
+
+        modal_text
+      end
+
+      def reset_modals
+        @accept_modal = []
+        @modal_response = nil
+        @modal_messages = []
+      end
+
+      def before_click(node, name, _keys = [], offset = {})
+        evaluate_on(node: node, expression: "_cuprite.scrollIntoViewport(this)")
+
+        # If offset is given it may go outside of the element and likely error
+        # will be raised that we detected another element at this position.
+        return true if offset[:x] || offset[:y]
+
+        x, y = find_position(node, **offset)
+        evaluate_on(node: node, expression: "_cuprite.mouseEventTest(this, '#{name}', #{x}, #{y})")
+        true
+      rescue Ferrum::JavaScriptError => e
+        raise MouseEventFailed, e.message if e.class_name == "MouseEventFailed"
+      end
+
+      def switch_to_frame(handle)
+        case handle
+        when :parent
+          @frame_stack.pop
+        when :top
+          @frame_stack = []
+        else
+          @frame_stack << handle
+          inject_extensions
+        end
+      end
+
+      def frame_name
+        evaluate("window.name")
+      end
+
+      def title
+        active_frame.current_title
+      end
+
+      private
+
+      # rubocop:disable Metrics/CyclomaticComplexity
+      # rubocop:disable Metrics/PerceivedComplexity
+      # rubocop:disable Style/GuardClause
+      def prepare_page
+        super
+
+        network.intercept if !Array(@browser.url_whitelist).empty? ||
+                             !Array(@browser.url_blacklist).empty?
+
+        on(:request) do |request, index, total|
+          if @browser.url_blacklist && !@browser.url_blacklist.empty?
+            if @browser.url_blacklist.any? { |r| request.match?(r) }
+              request.abort and next
+            else
+              request.continue and next
+            end
+          elsif @browser.url_whitelist && !@browser.url_whitelist.empty?
+            if @browser.url_whitelist.any? { |r| request.match?(r) }
+              request.continue and next
+            else
+              request.abort and next
+            end
+          elsif index + 1 < total
+            # There are other callbacks that may handle this request
+            next
+          else
+            # If there are no callbacks then just continue
+            request.continue
+          end
+        end
+
+        on("Page.javascriptDialogOpening") do |params|
+          accept_modal = @accept_modal.last
+          if [true, false].include?(accept_modal)
+            @accept_modal.pop
+            @modal_messages << params["message"]
+            options = { accept: accept_modal }
+            response = @modal_response || params["defaultPrompt"]
+          else
+            with_text = params["message"] ? "with text `#{params['message']}` " : ""
+            warn "Modal window #{with_text}has been opened, but you didn't wrap " \
+                 "your code into (`accept_prompt` | `dismiss_prompt` | " \
+                 "`accept_confirm` | `dismiss_confirm` | `accept_alert`), " \
+                 "accepting by default"
+            options = { accept: true }
+            response = params["defaultPrompt"]
+          end
+          options.merge!(promptText: response) if response
+          command("Page.handleJavaScriptDialog", **options)
+        end
+      end
+      # rubocop:enable Metrics/CyclomaticComplexity
+      # rubocop:enable Metrics/PerceivedComplexity
+      # rubocop:enable Style/GuardClause
+
+      def find_position(node, **options)
+        node.find_position(**options)
+      rescue Ferrum::BrowserError => e
+        raise MouseEventFailed, "MouseEventFailed: click, none, 0, 0" if e.message == "Could not compute content quads."
+
+        raise
+      end
+
+      def active_frame
+        if @frame_stack.empty?
+          main_frame
+        else
+          @frames[@frame_stack.last]
+        end
+      end
+    end
+  end
+end

data/lib/capybara/cuprite/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Capybara
+  module Cuprite
+    VERSION = "0.14.2"
+  end
+end

data/lib/capybara/cuprite.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require "ferrum"
+require "capybara"
+require "capybara/cuprite/driver"
+require "capybara/cuprite/browser"
+require "capybara/cuprite/page"
+require "capybara/cuprite/node"
+require "capybara/cuprite/errors"
+
+Capybara.register_driver(:cuprite) do |app|
+  Capybara::Cuprite::Driver.new(app)
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cuprite
 version: !ruby/object:Gem::Version
-  version: 0.14.1
+  version: 0.14.2
 platform: ruby
 authors:
 - Dmitry Vorotilin
@@ -171,7 +171,18 @@ email:
 executables: []
 extensions: []
 extra_rdoc_files: []
-files: []
+files:
+- LICENSE
+- README.md
+- lib/capybara/cuprite.rb
+- lib/capybara/cuprite/browser.rb
+- lib/capybara/cuprite/cookie.rb
+- lib/capybara/cuprite/driver.rb
+- lib/capybara/cuprite/errors.rb
+- lib/capybara/cuprite/javascripts/index.js
+- lib/capybara/cuprite/node.rb
+- lib/capybara/cuprite/page.rb
+- lib/capybara/cuprite/version.rb
 homepage: https://github.com/rubycdp/cuprite
 licenses:
 - MIT