cuprite 0.19 → 0.20

data/lib/capybara/cuprite/driver/deprecations.rb

@@ -0,0 +1,198 @@
+# frozen_string_literal: true
+
+require "uri"
+require "capybara/cuprite/deprecation"
+
+module Capybara
+  module Cuprite
+    class Driver < Capybara::Driver::Base
+      module Deprecations
+        def self.deprecate(name, replacement)
+          define_method(name) do |*args, **kwargs, &block|
+            Cuprite.deprecation_warning("#{self.class}##{name}", "use ##{replacement}")
+            public_send(replacement, *args, **kwargs, &block)
+          end
+        end
+        private_class_method :deprecate
+
+        deprecate :body, :html
+        deprecate :window_handle, :current_window_handle
+        deprecate :back, :go_back
+        deprecate :forward, :go_forward
+        deprecate :render, :save_screenshot
+
+        def render_base64(format = :png, options = {})
+          Cuprite.deprecation_warning("#{self.class}#render_base64", "use page.driver.browser.screenshot or .pdf")
+          browser.screenshot(format: format, encoding: :base64, **options)
+        end
+
+        def zoom_factor=(value)
+          Cuprite.deprecation_warning("#{self.class}#zoom_factor=", "pass scale: to save_screenshot")
+          @zoom_factor = value.to_f
+        end
+
+        def paper_size=(value)
+          Cuprite.deprecation_warning("#{self.class}#paper_size=",
+                                      "pass paper_width: and paper_height: to save_screenshot")
+          @paper_size = value
+        end
+
+        def resize(width, height)
+          Cuprite.deprecation_warning("#{self.class}##{__callee__}", "use page.current_window.resize_to")
+          resize_window_to(current_window_handle, width, height)
+        end
+        alias resize_window resize
+
+        def click(x, y)
+          Cuprite.deprecation_warning("#{self.class}#click", "use page.driver.browser.mouse.click")
+          browser.mouse.click(x: x, y: y)
+        end
+
+        def scroll_to(left, top)
+          Cuprite.deprecation_warning("#{self.class}#scroll_to", "use page.scroll_to")
+          browser.mouse.scroll_to(left, top)
+        end
+
+        def set_proxy(host, port, user = nil, password = nil, bypass = nil)
+          Cuprite.deprecation_warning("#{self.class}#set_proxy", "pass the :proxy option to the driver")
+          @options.merge!(proxy: { host: host, port: port, user: user, password: password, bypass: bypass })
+        end
+
+        def restart
+          Cuprite.deprecation_warning("#{self.class}#restart", "use page.driver.browser.restart")
+          browser.restart
+        end
+
+        def wait_for_reload(timeout = 1)
+          Cuprite.deprecation_warning("#{self.class}#wait_for_reload", "use page.driver.browser.wait_for_reload")
+          browser.wait_for_reload(timeout)
+        end
+
+        def timeout
+          Cuprite.deprecation_warning("#{self.class}#timeout", "use page.driver.browser.timeout")
+          browser.timeout
+        end
+
+        def timeout=(value)
+          Cuprite.deprecation_warning("#{self.class}#timeout=", "use page.driver.browser.timeout=")
+          browser.timeout = value
+        end
+
+        def device_pixel_ratio
+          Cuprite.deprecation_warning("#{self.class}#device_pixel_ratio", "use page.driver.browser.device_pixel_ratio")
+          browser.device_pixel_ratio
+        end
+
+        def viewport_size
+          Cuprite.deprecation_warning("#{self.class}#viewport_size", "use page.driver.browser.viewport_size")
+          browser.viewport_size
+        end
+
+        def authorize(user, password)
+          Cuprite.deprecation_warning("#{self.class}##{__callee__}", "use page.driver.browser.network.authorize")
+          browser.network.authorize(user: user, password: password) do |request, _index, _total|
+            request.continue
+          end
+        end
+        alias basic_authorize authorize
+
+        def headers
+          Cuprite.deprecation_warning("#{self.class}#headers", "use page.driver.browser.headers.get")
+          browser.headers.get
+        end
+
+        def headers=(headers)
+          Cuprite.deprecation_warning("#{self.class}#headers=", "use page.driver.browser.headers.set")
+          browser.headers.set(headers)
+        end
+
+        def add_headers(headers)
+          Cuprite.deprecation_warning("#{self.class}#add_headers", "use page.driver.browser.headers.add")
+          browser.headers.add(headers)
+        end
+
+        def add_header(name, value, permanent: true)
+          Cuprite.deprecation_warning("#{self.class}#add_header", "use page.driver.browser.headers.add")
+          browser.headers.add({ name => value }, permanent: permanent)
+        end
+
+        def cookies
+          Cuprite.deprecation_warning("#{self.class}#cookies", "use page.driver.browser.cookies.all")
+          browser.cookies.all
+        end
+
+        def set_cookie(name, value, options = {})
+          Cuprite.deprecation_warning("#{self.class}#set_cookie", "use page.driver.browser.cookies.set")
+          options = options.dup
+          options[:name]   ||= name
+          options[:value]  ||= value
+          options[:domain] ||= default_domain
+          browser.cookies.set(**options)
+        end
+
+        def remove_cookie(name, **options)
+          Cuprite.deprecation_warning("#{self.class}#remove_cookie", "use page.driver.browser.cookies.remove")
+          options[:domain] = default_domain if options.empty?
+          options = options.merge(name: name)
+          browser.cookies.remove(**options)
+        end
+
+        def clear_cookies
+          Cuprite.deprecation_warning("#{self.class}#clear_cookies", "use page.driver.browser.cookies.clear")
+          browser.cookies.clear
+        end
+
+        def network_traffic(type = nil)
+          Cuprite.deprecation_warning("#{self.class}#network_traffic", "use page.driver.browser.network.traffic")
+          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
+          Cuprite.deprecation_warning("#{self.class}#clear_network_traffic",
+                                      "use page.driver.browser.network.clear(:traffic)")
+          browser.network.clear(:traffic)
+        end
+
+        def wait_for_network_idle(**options)
+          Cuprite.deprecation_warning("#{self.class}#wait_for_network_idle",
+                                      "use page.driver.browser.network.wait_for_idle")
+          browser.network.wait_for_idle(**options)
+        end
+
+        def clear_memory_cache
+          Cuprite.deprecation_warning("#{self.class}#clear_memory_cache",
+                                      "use page.driver.browser.network.clear(:cache)")
+          browser.network.clear(:cache)
+        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
+        end
+
+        def default_cookie_host
+          if respond_to?(:session_options)
+            session_options.app_host
+          else
+            Capybara.app_host
+          end || ""
+        end
+      end
+    end
+  end
+end

data/lib/capybara/cuprite/driver/extensions.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Capybara
+  module Cuprite
+    class Driver < Capybara::Driver::Base
+      module Extensions
+        def debug(...)
+          browser.debug(...)
+        end
+      end
+    end
+  end
+end

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
@@ -52,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
@@ -73,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)
@@ -84,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
 
@@ -110,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
@@ -140,6 +145,8 @@ 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
@@ -147,7 +154,7 @@ module Capybara
       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)
@@ -155,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
 
@@ -200,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
@@ -338,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)
@@ -387,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
@@ -407,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