cuprite 0.18 → 0.20

data/lib/capybara/cuprite/driver.rb

@@ -1,27 +1,42 @@
 # frozen_string_literal: true
 
-require "uri"
 require "forwardable"
+require "capybara/cuprite/finder"
+require "capybara/cuprite/driver/deprecations"
+require "capybara/cuprite/driver/extensions"
 
-# rubocop:disable-next Metrics/ClassLength
 module Capybara
   module Cuprite
     class Driver < Capybara::Driver::Base
       DEFAULT_MAXIMIZE_SCREEN_SIZE = [1366, 768].freeze
       EXTENSION = File.expand_path("javascripts/index.js", __dir__)
+      CALLBACK_JS = <<~JS
+        function(...args) {
+          return new Promise((resolve, reject) => {
+            try {
+              (function() {
+                SCRIPT
+              }).apply(this, [...args, resolve]);
+            } catch (error) {
+              reject(error);
+            }
+          });
+        }
+      JS
 
       extend Forwardable
+      include Deprecations
+      include Extensions
 
-      delegate %i[restart quit status_code timeout timeout= current_url title body
-                  window_handles close_window switch_to_window within_window window_handle
-                  back forward refresh wait_for_reload viewport_size device_pixel_ratio] => :browser
+      delegate %i[quit current_url title
+                  window_handles current_window_handle close_window switch_to_window
+                  refresh] => :browser
       delegate %i[send_keys] => :active_element
-      alias html body
-      alias current_window_handle window_handle
-      alias go_back back
-      alias go_forward forward
+      def_delegator :browser, :body, :html
+      def_delegator :browser, :back, :go_back
+      def_delegator :browser, :forward, :go_forward
 
-      attr_reader :app, :options, :screen_size
+      attr_reader :app, :options
 
       def initialize(app, options = {})
         @app     = app
@@ -42,6 +57,7 @@ module Capybara
         unless @options[:browser_options][:"remote-allow-origins"]
           @options[:browser_options].merge!("remote-allow-origins": "*")
         end
+        @options[:browser_options] = { "disable-web-security": nil }.merge(@options[:browser_options])
 
         super()
       end
@@ -51,20 +67,21 @@ module Capybara
       end
 
       def browser
-        @browser ||= Browser.new(@options)
+        @browser ||= Browser.new({ base_url: capybara_base_url }.compact.merge(@options))
       end
 
       def visit(url)
         @started = true
-        browser.visit(url)
+        browser.base_url = url if url.match?(%r{\Ahttps?://})
+        browser.goto(url)
       end
 
-      def frame_url
-        evaluate_script("window.location.href")
+      def status_code
+        browser.network.status
       end
 
-      def source
-        browser.source.to_s
+      def frame_url
+        evaluate_script("window.location.href")
       end
 
       def frame_title
@@ -72,7 +89,7 @@ module Capybara
       end
 
       def active_element
-        Node.new(self, browser.active_element)
+        Node.new(self, browser.evaluate("document.activeElement"))
       end
 
       def find_xpath(selector)
@@ -83,21 +100,13 @@ module Capybara
         find(:css, selector)
       end
 
-      def find(method, selector)
-        browser.find(method, selector).map { |native| Node.new(self, native) }
-      end
-
-      def click(x, y)
-        browser.mouse.click(x: x, y: y)
-      end
-
       def evaluate_script(script, *args)
         result = browser.evaluate(script, *native_args(args))
         unwrap_script_result(result)
       end
 
       def evaluate_async_script(script, *args)
-        result = browser.evaluate_async(script, session_wait_time, *native_args(args))
+        result = browser.evaluate(CALLBACK_JS.sub("SCRIPT") { script }, *native_args(args), timeout: session_wait_time)
         unwrap_script_result(result)
       end
 
@@ -109,23 +118,20 @@ module Capybara
       def switch_to_frame(locator)
         handle = case locator
                  when Capybara::Node::Element
-                   locator.native.description["frameId"]
+                   locator.native.node.description["frameId"]
                  when Capybara::Cuprite::Node
-                   locator.description["frameId"]
+                   locator.node.description["frameId"]
                  when :parent, :top
                    locator
                  end
 
         raise ArgumentError, "Unable to switch to frame from #{locator.class}" unless handle
 
-        browser.switch_to_frame(handle)
+        browser.page.switch_to_frame(handle)
       end
 
       def open_new_window
-        target = browser.default_context.create_target
-        target.maybe_sleep_if_new_window
-        target.page = Page.new(target.client, context_id: target.context_id, target_id: target.id)
-        target.page
+        browser.open_new_window
       end
 
       def no_such_window_error
@@ -139,13 +145,16 @@ module Capybara
         browser.url_whitelist = @options[:url_whitelist]
         browser.raise_on_unhandled_modal = @options.fetch(:raise_on_unhandled_modal, false)
         browser.reset
+        base_url = @options[:base_url] || capybara_base_url
+        browser.base_url = base_url if base_url
+      ensure
         @started = false
       end
 
       def save_screenshot(path, options = {})
         options[:scale] = @zoom_factor if @zoom_factor
 
-        if pdf?(path, options)
+        if File.extname(path) == ".pdf"
           options[:paperWidth] = @paper_size[:width].to_f if @paper_size
           options[:paperHeight] = @paper_size[:height].to_f if @paper_size
           browser.pdf(path: path, **options)
@@ -153,32 +162,10 @@ module Capybara
           browser.screenshot(path: path, **options)
         end
       end
-      alias render save_screenshot
-
-      def render_base64(format = :png, options = {})
-        if pdf?(nil, options)
-          options[:paperWidth] = @paper_size[:width].to_f if @paper_size
-          options[:paperHeight] = @paper_size[:height].to_f if @paper_size
-          browser.pdf(encoding: :base64, **options)
-        else
-          browser.screenshot(format: format, encoding: :base64, **options)
-        end
-      end
-
-      def zoom_factor=(value)
-        @zoom_factor = value.to_f
-      end
-
-      attr_writer :paper_size
-
-      def resize(width, height)
-        browser.resize(width: width, height: height)
-      end
-      alias resize_window resize
 
       def resize_window_to(handle, width, height)
         within_window(handle) do
-          resize(width, height)
+          browser.resize(width: width, height: height)
         end
       end
 
@@ -198,129 +185,10 @@ module Capybara
         end
       end
 
-      def scroll_to(left, top)
-        browser.mouse.scroll_to(left, top)
-      end
-
-      def network_traffic(type = nil)
-        traffic = browser.network.traffic
-
-        case type.to_s
-        when "all"
-          traffic
-        when "blocked"
-          traffic.select(&:blocked?)
-        else
-          # when request isn't blocked
-          traffic.reject(&:blocked?)
-        end
-      end
-
-      def clear_network_traffic
-        browser.network.clear(:traffic)
-      end
-
-      def set_proxy(host, port, user = nil, password = nil, bypass = nil)
-        @options.merge!(proxy: { host: host, port: port, user: user, password: password, bypass: bypass })
-      end
-
-      def headers
-        browser.headers.get
-      end
-
-      def headers=(headers)
-        browser.headers.set(headers)
-      end
-
-      def add_headers(headers)
-        browser.headers.add(headers)
-      end
-
-      def add_header(name, value, permanent: true)
-        browser.headers.add({ name => value }, permanent: permanent)
-      end
-
       def response_headers
         browser.network.response&.headers
       end
 
-      def cookies
-        browser.cookies.all
-      end
-
-      def set_cookie(name, value, options = {})
-        options = options.dup
-        options[:name]   ||= name
-        options[:value]  ||= value
-        options[:domain] ||= default_domain
-        browser.cookies.set(**options)
-      end
-
-      def remove_cookie(name, **options)
-        options[:domain] = default_domain if options.empty?
-        options = options.merge(name: name)
-        browser.cookies.remove(**options)
-      end
-
-      def clear_cookies
-        browser.cookies.clear
-      end
-
-      def wait_for_network_idle(**options)
-        browser.network.wait_for_idle(**options)
-      end
-
-      def clear_memory_cache
-        browser.network.clear(:cache)
-      end
-
-      def basic_authorize(user, password)
-        browser.network.authorize(user: user, password: password) do |request, _index, _total|
-          request.continue
-        end
-      end
-      alias authorize basic_authorize
-
-      def debug(...)
-        browser.debug(...)
-      end
-
-      def pause
-        # STDIN is not necessarily connected to a keyboard. It might even be closed.
-        # So we need a method other than keypress to continue.
-
-        # In jRuby - STDIN returns immediately from select
-        # see https://github.com/jruby/jruby/issues/1783
-        read, write = IO.pipe
-        thread = Thread.new do
-          IO.copy_stream($stdin, write)
-          write.close
-        end
-
-        warn "Cuprite execution paused. Press enter (or run 'kill -CONT #{Process.pid}') to continue."
-
-        signal = false
-        old_trap = trap("SIGCONT") do
-          signal = true
-          warn "\nSignal SIGCONT received"
-        end
-        keyboard = read.wait_readable(1) until keyboard || signal # wait for data on STDIN or signal SIGCONT received
-
-        unless signal
-          begin
-            input = read.read_nonblock(80) # clear out the read buffer
-            puts unless input&.end_with?("\n")
-          rescue EOFError, IO::WaitReadable
-            # Ignore problems reading from STDIN.
-          end
-        end
-      ensure
-        thread.kill
-        read.close
-        trap("SIGCONT", old_trap) # Restore the previous signal handler, if there was one.
-        warn "Continuing"
-      end
-
       def wait?
         true
       end
@@ -336,37 +204,49 @@ module Capybara
       def accept_modal(type, options = {})
         case type
         when :alert, :confirm
-          browser.accept_confirm
+          browser.page.accept_confirm
         when :prompt
-          browser.accept_prompt(options[:with])
+          browser.page.accept_prompt(options[:with])
         end
 
         yield if block_given?
 
-        browser.find_modal(options)
+        browser.page.find_modal(options)
       end
 
       def dismiss_modal(type, options = {})
         case type
         when :confirm
-          browser.dismiss_confirm
+          browser.page.dismiss_confirm
         when :prompt
-          browser.dismiss_prompt
+          browser.page.dismiss_prompt
         end
 
         yield if block_given?
 
-        browser.find_modal(options)
+        browser.page.find_modal(options)
       end
 
       private
 
-      def default_domain
-        if @started
-          URI.parse(browser.current_url).host
-        else
-          URI.parse(default_cookie_host).host || "127.0.0.1"
-        end
+      attr_reader :screen_size
+
+      def find(method, selector)
+        Finder.find(browser, method, selector).map { |native| Node.new(self, native) }
+      end
+
+      def within_window(handle)
+        original = browser.current_window_handle
+        raise Ferrum::NoSuchPageError unless browser.window_handles.include?(handle)
+
+        browser.switch_to_window(handle)
+        yield
+      ensure
+        browser.switch_to_window(original)
+      end
+
+      def capybara_base_url
+        session_options.app_host || session&.server&.base_url
       end
 
       def native_args(args)
@@ -385,14 +265,6 @@ module Capybara
         end
       end
 
-      def default_cookie_host
-        if respond_to?(:session_options)
-          session_options.app_host
-        else
-          Capybara.app_host
-        end || ""
-      end
-
       def unwrap_script_result(arg)
         case arg
         when Array
@@ -405,11 +277,6 @@ module Capybara
           arg
         end
       end
-
-      def pdf?(path, options)
-        (path && File.extname(path).delete(".") == "pdf") ||
-          options[:format].to_s == "pdf"
-      end
     end
   end
 end

data/lib/capybara/cuprite/finder.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Capybara
+  module Cuprite
+    module Finder
+      module_function
+
+      def find(browser, method, selector, within = nil)
+        # Capybara appends its text-match hint as `(expr)[...]`, but with `exact_text: true` the hint
+        # is empty and the result `(expr)[]` is invalid XPath. An empty predicate is never valid, so
+        # dropping it can't change a valid selector. Remove once teamcapybara/capybara#2860 is released.
+        selector = selector.delete_suffix("[]") if method == :xpath
+        nodes = browser.evaluate("_cuprite.find(...arguments)", *[method, selector, within].compact)
+        nodes.select(&:node?)
+      rescue Ferrum::JavaScriptError => e
+        raise InvalidSelector.new(e.response, method, selector) if e.class_name == "InvalidSelector"
+
+        raise
+      end
+    end
+  end
+end

data/lib/capybara/cuprite/javascripts/drag.js

@@ -1,118 +1,115 @@
 // HTML5 drag-and-drop emulation.
 //
-// Ported near-verbatim from Capybara's Selenium driver
-// (capybara/selenium/extensions/html5_drag.rb, HTML5_DRAG_DROP_SCRIPT) so
-// Cuprite matches Capybara's HTML5 drag behaviour and its shared specs. Kept
-// close to the source to ease future syncs; known upstream quirks (rectPt.top
-// in pointOnRect, undeclared `key`, callback.call(true)) are preserved
-// deliberately. See https://github.com/rubycdp/cuprite/issues/314.
-
-function rectCenter(rect){
-  return new DOMPoint(
-    (rect.left + rect.right)/2,
-    (rect.top + rect.bottom)/2
-  );
-}
-
-function pointOnRect(pt, rect) {
-  var rectPt = rectCenter(rect);
-  var slope = (rectPt.y - pt.y) / (rectPt.x - pt.x);
-
-  if (pt.x <= rectPt.x) { // left side
-    var minXy = slope * (rect.left - pt.x) + pt.y;
-    if (rect.top <= minXy && minXy <= rect.bottom)
-      return new DOMPoint(rect.left, minXy);
+// Ported from Capybara's Selenium driver (capybara/selenium/extensions/html5_drag.rb,
+// HTML5_DRAG_DROP_SCRIPT), see https://github.com/rubycdp/cuprite/issues/314.
+// Unlike the original, a drag ends the way it does in a browser: with `drop` if
+// the target accepted it, otherwise with `dragleave`, never both [#325].
+
+(function(source, target, step_delay, drop_modifier_keys, drop_offset, callback) {
+  function rectCenter(rect){
+    return new DOMPoint(
+      (rect.left + rect.right)/2,
+      (rect.top + rect.bottom)/2
+    );
   }
 
-  if (pt.x >= rectPt.x) { // right side
-    var maxXy = slope * (rect.right - pt.x) + pt.y;
-    if (rect.top <= maxXy && maxXy <= rect.bottom)
-      return new DOMPoint(rect.right, maxXy);
+  function pointOnRect(pt, rect) {
+    var rectPt = rectCenter(rect);
+    var slope = (rectPt.y - pt.y) / (rectPt.x - pt.x);
+
+    if (pt.x <= rectPt.x) { // left side
+      var minXy = slope * (rect.left - pt.x) + pt.y;
+      if (rect.top <= minXy && minXy <= rect.bottom)
+        return new DOMPoint(rect.left, minXy);
+    }
+
+    if (pt.x >= rectPt.x) { // right side
+      var maxXy = slope * (rect.right - pt.x) + pt.y;
+      if (rect.top <= maxXy && maxXy <= rect.bottom)
+        return new DOMPoint(rect.right, maxXy);
+    }
+
+    if (pt.y <= rectPt.y) { // top side
+      var minYx = (rect.top - pt.y) / slope + pt.x;
+      if (rect.left <= minYx && minYx <= rect.right)
+        return new DOMPoint(minYx, rect.top);
+    }
+
+    if (pt.y >= rectPt.y) { // bottom side
+      var maxYx = (rect.bottom - pt.y) / slope + pt.x;
+      if (rect.left <= maxYx && maxYx <= rect.right)
+        return new DOMPoint(maxYx, rect.bottom);
+    }
+
+    return new DOMPoint(pt.x,pt.y);
+  }
+
+  function dragEnterTarget() {
+    target.scrollIntoView({behavior: 'instant', block: 'center', inline: 'center'});
+    var targetRect = target.getBoundingClientRect();
+    var sourceCenter = rectCenter(source.getBoundingClientRect());
+
+    for (var i = 0; i < drop_modifier_keys.length; i++) {
+      var key = drop_modifier_keys[i];
+      if (key == "control"){
+        key = "ctrl"
+      }
+      opts[key + 'Key'] = true;
+    }
+
+    var dragEnterEvent = new DragEvent('dragenter', opts);
+    target.dispatchEvent(dragEnterEvent);
+
+    // fire 2 dragover events to simulate dragging with a direction
+    var entryPoint = pointOnRect(sourceCenter, targetRect)
+    var dragOverOpts = Object.assign({clientX: entryPoint.x, clientY: entryPoint.y}, opts);
+    var dragOverEvent = new DragEvent('dragover', dragOverOpts);
+    target.dispatchEvent(dragOverEvent);
+    window.setTimeout(dragOnTarget, step_delay);
   }
 
-  if (pt.y <= rectPt.y) { // top side
-    var minYx = (rectPt.top - pt.y) / slope + pt.x;
-    if (rect.left <= minYx && minYx <= rect.right)
-      return new DOMPoint(minYx, rect.top);
+  function dropPoint(rect) {
+    if (!drop_offset) return rectCenter(rect);
+
+    var origin = drop_offset.position == 'center' ? rectCenter(rect) : new DOMPoint(rect.left, rect.top);
+    return new DOMPoint(origin.x + drop_offset.x, origin.y + drop_offset.y);
   }
 
-  if (pt.y >= rectPt.y) { // bottom side
-    var maxYx = (rect.bottom - pt.y) / slope + pt.x;
-    if (rect.left <= maxYx && maxYx <= rect.right)
-      return new DOMPoint(maxYx, rect.bottom);
+  function dragOnTarget() {
+    var point = dropPoint(target.getBoundingClientRect());
+    var dragOverOpts = Object.assign({clientX: point.x, clientY: point.y}, opts);
+    var dragOverEvent = new DragEvent('dragover', dragOverOpts);
+    target.dispatchEvent(dragOverEvent);
+    window.setTimeout(dragEnd, step_delay, dragOverEvent.defaultPrevented, dragOverOpts);
   }
 
-  return new DOMPoint(pt.x,pt.y);
-}
+  function dragEnd(drop, dragOverOpts) {
+    var dragEndOptions = Object.assign({}, opts, dragOverOpts);
+    var dropOrLeaveEvent = new DragEvent(drop ? 'drop' : 'dragleave', dragEndOptions);
+    target.dispatchEvent(dropOrLeaveEvent);
+    var dragEndEvent = new DragEvent('dragend', dragEndOptions);
+    source.dispatchEvent(dragEndEvent);
+    callback.call(true);
+  }
 
-function dragEnterTarget() {
-  target.scrollIntoView({behavior: 'instant', block: 'center', inline: 'center'});
-  var targetRect = target.getBoundingClientRect();
-  var sourceCenter = rectCenter(source.getBoundingClientRect());
+  var dt = new DataTransfer();
+  var opts = { cancelable: true, bubbles: true, dataTransfer: dt };
 
-  for (var i = 0; i < drop_modifier_keys.length; i++) {
-    key = drop_modifier_keys[i];
-    if (key == "control"){
-      key = "ctrl"
-    }
-    opts[key + 'Key'] = true;
+  while (source && !source.draggable) {
+    source = source.parentElement;
   }
 
-  var dragEnterEvent = new DragEvent('dragenter', opts);
-  target.dispatchEvent(dragEnterEvent);
-
-  // fire 2 dragover events to simulate dragging with a direction
-  var entryPoint = pointOnRect(sourceCenter, targetRect)
-  var dragOverOpts = Object.assign({clientX: entryPoint.x, clientY: entryPoint.y}, opts);
-  var dragOverEvent = new DragEvent('dragover', dragOverOpts);
-  target.dispatchEvent(dragOverEvent);
-  window.setTimeout(dragOnTarget, step_delay);
-}
-
-function dragOnTarget() {
-  var targetCenter = rectCenter(target.getBoundingClientRect());
-  var dragOverOpts = Object.assign({clientX: targetCenter.x, clientY: targetCenter.y}, opts);
-  var dragOverEvent = new DragEvent('dragover', dragOverOpts);
-  target.dispatchEvent(dragOverEvent);
-  window.setTimeout(dragLeave, step_delay, dragOverEvent.defaultPrevented, dragOverOpts);
-}
-
-function dragLeave(drop, dragOverOpts) {
-  var dragLeaveOptions = Object.assign({}, opts, dragOverOpts);
-  var dragLeaveEvent = new DragEvent('dragleave', dragLeaveOptions);
-  target.dispatchEvent(dragLeaveEvent);
-  if (drop) {
-    var dropEvent = new DragEvent('drop', dragLeaveOptions);
-    target.dispatchEvent(dropEvent);
+  if (source.tagName == 'A'){
+    dt.setData('text/uri-list', source.href);
+    dt.setData('text', source.href);
+  }
+  if (source.tagName == 'IMG'){
+    dt.setData('text/uri-list', source.src);
+    dt.setData('text', source.src);
   }
-  var dragEndEvent = new DragEvent('dragend', dragLeaveOptions);
-  source.dispatchEvent(dragEndEvent);
-  callback.call(true);
-}
-
-var source = arguments[0],
-    target = arguments[1],
-    step_delay = arguments[2],
-    drop_modifier_keys = arguments[3],
-    callback = arguments[4];
-
-var dt = new DataTransfer();
-var opts = { cancelable: true, bubbles: true, dataTransfer: dt };
-
-while (source && !source.draggable) {
-  source = source.parentElement;
-}
-
-if (source.tagName == 'A'){
-  dt.setData('text/uri-list', source.href);
-  dt.setData('text', source.href);
-}
-if (source.tagName == 'IMG'){
-  dt.setData('text/uri-list', source.src);
-  dt.setData('text', source.src);
-}
-
-var dragEvent = new DragEvent('dragstart', opts);
-source.dispatchEvent(dragEvent);
-
-window.setTimeout(dragEnterTarget, step_delay);
+
+  var dragEvent = new DragEvent('dragstart', opts);
+  source.dispatchEvent(dragEvent);
+
+  window.setTimeout(dragEnterTarget, step_delay);
+}).apply(this, arguments);