cuprite 0.12 → 0.15.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bac1e4393d6796d34198e45428ea8d443b67136e4805e77f7c7d3f35451cefbb
-  data.tar.gz: 27edf7157ac47b0a6bbc579e7908aaa0313d91b7f3702417453f76f1230e882d
+  metadata.gz: 78b7dde58d02147e2985473da0a7527d338ff086e4a4aaf0fd9302e5faf3ee11
+  data.tar.gz: 777726c6161975950df923a305b0bdb9da54b5531b7a5339ed0d4beaf264beb6
 SHA512:
-  metadata.gz: a8ed43b593e4a071e449a80ac92925abafff1d9afa2a3934783963a19411deddcc18b1906467d5d355a93ed891ec4aae4b21509031190020d154202ba21904e8
-  data.tar.gz: ed39a7d445203f93b402fc313caa883449d7e743a6690196ba7f6bed9ee1d8c506f06d4b8ae620c8bc9d1c21c5770458b88564e9e937f7b5583e01a931fece39
+  metadata.gz: 04e88a47d9d2d2df68ad11dca8224f6d24001340b1743f538e6fdb64e818381037da7987b9db25284336b469c986d9d9e883192743749c4c6cad6c43adc160a1
+  data.tar.gz: a059dae9790af13c8a56999d6d76d5920e863e217b346a721a4051f0cc786e295a35c0e574c00e425b87e2d0c7a8b140c991183ab3246d1678566318745c9ecf

data/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2018-2021 Dmitry Vorotilin
+Copyright (c) 2018-2022 Dmitry Vorotilin
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -4,12 +4,7 @@ Cuprite is a pure Ruby driver (read as _no_ Selenium/WebDriver/ChromeDriver
 dependency) for [Capybara](https://github.com/teamcapybara/capybara). It allows
 you to run Capybara tests on a headless Chrome or Chromium. Under the hood it
 uses [Ferrum](https://github.com/rubycdp/ferrum#index) which is high-level API
-to the browser by CDP protocol. The design of the driver is as close to
-[Poltergeist](https://github.com/teampoltergeist/poltergeist) as possible though
-it's not a goal.
-
-[Cuprite](https://evrone.com/cuprite) designed & supported by [Evrone](https://evrone.com/)
-What else we build [with Ruby](https://evrone.com/ruby)
+to the browser by CDP protocol.
 
 
 ## Install
@@ -46,8 +41,7 @@ browser = page.driver.browser
 browser.mouse.move(x: 123, y: 456).down.up
 ```
 
-If you already have tests on Poltergeist then it should simply work, for
-Selenium you better check your code for `manage` calls because it works
+For Selenium you better check your code for `manage` calls because it works
 differently in Cuprite, see the documentation below.
 
 
@@ -67,8 +61,8 @@ end
 `Cuprite`-specific options are:
 
 * options `Hash`
-  * `:url_blacklist` (Array) - array of strings to match against requested URLs
-  * `:url_whitelist` (Array) - array of strings to match against requested URLs
+  * `:url_blacklist` (Array) - array of regexes to match against requested URLs
+  * `:url_whitelist` (Array) - array of regexes to match against requested URLs
 
 
 ## Debugging
@@ -186,6 +180,9 @@ Besides capybara screenshot method you can get image as Base64:
 ## Authorization
 
 * `page.driver.basic_authorize(user, password)`
+
+## Proxy
+
 * `page.driver.set_proxy(ip, port, type, user, password)`
 
 
@@ -195,16 +192,21 @@ Cuprite supports URL blacklisting, which allows you to prevent scripts from
 running on designated domains:
 
 ```ruby
-page.driver.browser.url_blacklist = ["http://www.example.com"]
+page.driver.browser.url_blacklist = %r{http://www.example.com}
 ```
 
 and also URL whitelisting, which allows scripts to only run on designated
 domains:
 
 ```ruby
-page.driver.browser.url_whitelist = ["http://www.example.com"]
+page.driver.browser.url_whitelist = %r{http://www.example.com}
 ```
 
 If you are experiencing slower run times, consider creating a URL whitelist of
 domains that are essential or a blacklist of domains that are not essential,
 such as ad networks or analytics, to your testing environment.
+
+## License
+
+The gem is available as open source under the terms of the
+[MIT License](https://opensource.org/licenses/MIT).

data/lib/capybara/cuprite/browser.rb

@@ -2,213 +2,254 @@
 
 require "forwardable"
 
-module Capybara::Cuprite
-  class Browser < Ferrum::Browser
-    extend Forwardable
+module Capybara
+  module Cuprite
+    class Browser < Ferrum::Browser
+      extend Forwardable
 
-    delegate %i[send_keys select set hover trigger before_click switch_to_frame
-                find_modal accept_confirm dismiss_confirm accept_prompt
-                dismiss_prompt reset_modals] => :page
+      delegate %i[send_keys select set hover trigger before_click switch_to_frame
+                  find_modal accept_confirm dismiss_confirm accept_prompt
+                  dismiss_prompt reset_modals] => :page
 
-    attr_reader :url_blacklist, :url_whitelist
+      def initialize(options = nil)
+        super
 
-    def initialize(options = nil)
-      options ||= {}
-      self.url_blacklist = options[:url_blacklist]
-      self.url_whitelist = options[:url_whitelist]
+        @options.url_blacklist = prepare_wildcards(options&.dig(:url_blacklist))
+        @options.url_whitelist = prepare_wildcards(options&.dig(:url_whitelist))
 
-      super
-      @page = false
-    end
+        @page = nil
+      end
 
-    def page
-      raise Ferrum::NoSuchPageError if @page.nil?
-      @page ||= attach_page
-    end
+      def command(...)
+        super
+      rescue Ferrum::DeadBrowserError
+        restart
+        raise
+      end
 
-    def reset
-      super
-      @page = attach_page
-    end
+      def page
+        raise Ferrum::NoSuchPageError if @page&.closed?
 
-    def quit
-      super
-      @page = false
-    end
+        @page ||= attach_page
+      end
 
-    def url_whitelist=(patterns)
-      @url_whitelist = prepare_wildcards(patterns)
-      page.network.intercept if @client && !@url_whitelist.empty?
-    end
+      def reset
+        super
+        @options.reset_window_size
+        @page = nil
+      end
 
-    def url_blacklist=(patterns)
-      @url_blacklist = prepare_wildcards(patterns)
-      page.network.intercept if @client && !@url_blacklist.empty?
-    end
+      def quit
+        super
+        @page = nil
+      end
 
-    def visit(*args)
-      goto(*args)
-    end
+      def resize(**options)
+        @options.window_size = [options[:width], options[:height]]
+        super
+      end
 
-    def status_code
-      network.status
-    end
+      def url_whitelist
+        @options.url_whitelist
+      end
+      alias url_allowlist url_whitelist
 
-    def find(method, selector)
-      find_all(method, selector)
-    end
+      def url_whitelist=(patterns)
+        @options.url_whitelist = prepare_wildcards(patterns)
+        page.network.whitelist = @options.url_whitelist if @client && @options.url_whitelist.any?
+      end
+      alias url_allowlist= url_whitelist=
 
-    def property(node, name)
-      node.property(name)
-    end
+      def url_blacklist
+        @options.url_blacklist
+      end
+      alias url_blocklist url_blacklist
 
-    def find_within(node, method, selector)
-      resolved = page.command("DOM.resolveNode", nodeId: node.node_id)
-      object_id = resolved.dig("object", "objectId")
-      find_all(method, selector, { "objectId" => object_id })
-    end
+      def url_blacklist=(patterns)
+        @options.url_blacklist = prepare_wildcards(patterns)
+        page.network.blacklist = @options.url_blacklist if @client && @options.url_blacklist.any?
+      end
+      alias url_blocklist= url_blacklist=
 
-    def window_handle
-      page.target_id
-    end
+      def visit(*args)
+        goto(*args)
+      end
 
-    def window_handles
-      targets.keys
-    end
+      def status_code
+        network.status
+      end
 
-    def within_window(locator = nil, &block)
-      original = window_handle
+      def find(method, selector)
+        find_all(method, selector)
+      end
 
-      if Capybara::VERSION.to_f < 3.0
-        target_id = window_handles.find do |target_id|
-          page = attach_page(target_id)
-          locator == page.frame_name
-        end
-        locator = target_id if target_id
+      def property(node, name)
+        node.property(name)
+      end
+
+      def find_within(node, method, selector)
+        resolved = page.command("DOM.resolveNode", nodeId: node.node_id)
+        object_id = resolved.dig("object", "objectId")
+        find_all(method, selector, { "objectId" => object_id })
+      end
+
+      def window_handle
+        page.target_id
       end
 
-      if window_handles.include?(locator)
+      def window_handles
+        targets.keys
+      end
+
+      def within_window(locator = nil)
+        original = window_handle
+        raise Ferrum::NoSuchPageError unless window_handles.include?(locator)
+
         switch_to_window(locator)
         yield
-      else
-        raise Ferrum::NoSuchPageError
+      ensure
+        switch_to_window(original)
       end
-    ensure
-      switch_to_window(original)
-    end
 
-    def switch_to_window(target_id)
-      target = targets[target_id]
-      raise Ferrum::NoSuchPageError unless target
-      @page = attach_page(target.id)
-    end
+      def switch_to_window(target_id)
+        target = targets[target_id]
+        raise Ferrum::NoSuchPageError unless target
 
-    def close_window(target_id)
-      target = targets[target_id]
-      raise Ferrum::NoSuchPageError unless target
-      @page = nil if @page.target_id == target.id
-      target.page.close
-    end
+        @page = attach_page(target.id)
+      end
 
-    def browser_error
-      evaluate("_cuprite.browserError()")
-    end
+      def close_window(target_id)
+        target = targets[target_id]
+        raise Ferrum::NoSuchPageError unless target
 
-    def source
-      raise NotImplementedError
-    end
+        @page = ClosedPage.new if @page.target_id == target.id
+        target.page.close
+        targets.delete(target_id) # page.close is async, delete target asap
+      end
 
-    def drag(node, other)
-      raise NotImplementedError
-    end
+      def active_element
+        evaluate("document.activeElement")
+      end
 
-    def drag_by(node, x, y)
-      raise NotImplementedError
-    end
+      def browser_error
+        evaluate("_cuprite.browserError()")
+      end
 
-    def select_file(node, value)
-      node.select_file(value)
-    end
+      def source
+        raise NotImplementedError
+      end
 
-    def parents(node)
-      evaluate_on(node: node, expression: "_cuprite.parents(this)", by_value: false)
-    end
+      def drag(node, other, steps, delay = nil)
+        x1, y1 = node.find_position
+        x2, y2 = other.find_position
 
-    def visible_text(node)
-      evaluate_on(node: node, expression: "_cuprite.visibleText(this)")
-    end
+        mouse.move(x: x1, y: y1)
+        mouse.down
+        sleep delay if delay
+        mouse.move(x: x2, y: y2, steps: steps)
+        mouse.up
+      end
 
-    def delete_text(node)
-      evaluate_on(node: node, expression: "_cuprite.deleteText(this)")
-    end
+      def drag_by(node, x, y, steps, delay = nil)
+        x1, y1 = node.find_position
+        x2 = x1 + x
+        y2 = y1 + y
 
-    def attributes(node)
-      value = evaluate_on(node: node, expression: "_cuprite.getAttributes(this)")
-      JSON.parse(value)
-    end
+        mouse.move(x: x1, y: y1)
+        mouse.down
+        sleep delay if delay
+        mouse.move(x: x2, y: y2, steps: steps)
+        mouse.up
+      end
 
-    def attribute(node, name)
-      evaluate_on(node: node, expression: %Q(_cuprite.getAttribute(this, "#{name}")))
-    end
+      def select_file(node, value)
+        node.select_file(value)
+      end
 
-    def value(node)
-      evaluate_on(node: node, expression: "_cuprite.value(this)")
-    end
+      def parents(node)
+        evaluate_on(node: node, expression: "_cuprite.parents(this)", by_value: false)
+      end
 
-    def visible?(node)
-      evaluate_on(node: node, expression: "_cuprite.isVisible(this)")
-    end
+      def visible_text(node)
+        evaluate_on(node: node, expression: "_cuprite.visibleText(this)")
+      end
 
-    def disabled?(node)
-      evaluate_on(node: node, expression: "_cuprite.isDisabled(this)")
-    end
+      def delete_text(node)
+        evaluate_on(node: node, expression: "_cuprite.deleteText(this)")
+      end
 
-    def path(node)
-      evaluate_on(node: node, expression: "_cuprite.path(this)")
-    end
+      def attributes(node)
+        value = evaluate_on(node: node, expression: "_cuprite.getAttributes(this)")
+        JSON.parse(value)
+      end
 
-    def all_text(node)
-      node.text
-    end
+      def attribute(node, name)
+        evaluate_on(node: node, expression: %(_cuprite.getAttribute(this, "#{name}")))
+      end
+
+      def value(node)
+        evaluate_on(node: node, expression: "_cuprite.value(this)")
+      end
+
+      def visible?(node)
+        evaluate_on(node: node, expression: "_cuprite.isVisible(this)")
+      end
+
+      def disabled?(node)
+        evaluate_on(node: node, expression: "_cuprite.isDisabled(this)")
+      end
+
+      def path(node)
+        evaluate_on(node: node, expression: "_cuprite.path(this)")
+      end
+
+      def all_text(node)
+        node.text
+      end
 
-    private
+      private
 
-    def find_all(method, selector, within = nil)
-      begin
+      def find_all(method, selector, within = nil)
         nodes = if within
-          evaluate("_cuprite.find(arguments[0], arguments[1], arguments[2])", method, selector, within)
-        else
-          evaluate("_cuprite.find(arguments[0], arguments[1])", method, selector)
-        end
+                  evaluate("_cuprite.find(arguments[0], arguments[1], arguments[2])", method, selector, within)
+                else
+                  evaluate("_cuprite.find(arguments[0], arguments[1])", method, selector)
+                end
 
-        nodes.map { |n| n.node? ? n : next }.compact
+        nodes.select(&:node?)
       rescue Ferrum::JavaScriptError => e
-        if e.class_name == "InvalidSelector"
-          raise InvalidSelector.new(e.response, method, selector)
-        end
+        raise InvalidSelector.new(e.response, method, selector) if e.class_name == "InvalidSelector"
+
         raise
       end
-    end
 
-    def prepare_wildcards(wc)
-      Array(wc).map do |wildcard|
-        if wildcard.is_a?(Regexp)
-          wildcard
-        else
-          wildcard = wildcard.gsub("*", ".*")
-          Regexp.new(wildcard, Regexp::IGNORECASE)
+      def prepare_wildcards(patterns)
+        string_passed = false
+
+        Array(patterns).map do |pattern|
+          if pattern.is_a?(Regexp)
+            pattern
+          else
+            string_passed = true
+            pattern = pattern.gsub("*", ".*")
+            Regexp.new(pattern, Regexp::IGNORECASE)
+          end
+        end
+      ensure
+        if string_passed
+          warn "Passing strings to blacklist/whitelist is deprecated, pass regexp at #{caller(4..4).first}"
         end
       end
-    end
 
-    def attach_page(target_id = nil)
-      target = targets[target_id] if target_id
-      target ||= default_context.default_target
-      return target.page if target.attached?
+      def attach_page(target_id = nil)
+        target = targets[target_id] if target_id
+        target ||= default_context.default_target
+        return target.page if target.connected?
 
-      target.maybe_sleep_if_new_window
-      target.page = Page.new(target.id, self)
-      target.page
+        target.maybe_sleep_if_new_window
+        target.page = Page.new(target.client, context_id: target.context_id, target_id: target.id)
+        target.page
+      end
     end
   end
 end

data/lib/capybara/cuprite/cookie.rb

@@ -1,46 +1,46 @@
 # frozen_string_literal: true
 
-module Capybara::Cuprite
-  class Cookie
-    def initialize(attributes)
-      @attributes = attributes
-    end
+module Capybara
+  module Cuprite
+    class Cookie
+      def initialize(attributes)
+        @attributes = attributes
+      end
 
-    def name
-      @attributes["name"]
-    end
+      def name
+        @attributes["name"]
+      end
 
-    def value
-      @attributes["value"]
-    end
+      def value
+        @attributes["value"]
+      end
 
-    def domain
-      @attributes["domain"]
-    end
+      def domain
+        @attributes["domain"]
+      end
 
-    def path
-      @attributes["path"]
-    end
+      def path
+        @attributes["path"]
+      end
 
-    def size
-      @attributes["size"]
-    end
+      def size
+        @attributes["size"]
+      end
 
-    def secure?
-      @attributes["secure"]
-    end
+      def secure?
+        @attributes["secure"]
+      end
 
-    def httponly?
-      @attributes["httpOnly"]
-    end
+      def httponly?
+        @attributes["httpOnly"]
+      end
 
-    def session?
-      @attributes["session"]
-    end
+      def session?
+        @attributes["session"]
+      end
 
-    def expires
-      if @attributes["expires"] > 0
-        Time.at(@attributes["expires"])
+      def expires
+        Time.at(@attributes["expires"]) if (@attributes["expires"]).positive?
       end
     end
   end