capybara-lightpanda 0.8.0 → 0.10.0

data/lib/capybara/lightpanda/node.rb

@@ -13,6 +13,22 @@ module Capybara
         @remote_object_id = remote_object_id
       end
 
+      # Capybara::Driver::Node#native returns the constructor's second argument,
+      # which here is the raw CDP objectId — a String. So the Selenium/Cuprite
+      # idiom `element.native.send_keys(...)` (solidus's
+      # return_authorizations_spec.rb does exactly that) died with
+      # "undefined method 'send_keys' for an instance of String". This driver
+      # has no lower-level node object behind the Capybara one — the CDP handle
+      # IS this Node (see #remote_object_id) — so `native` is self.
+      #
+      # Safe against Capybara::Driver::Node#==, which compares `native ==
+      # other.native` and would recurse forever on a self-returning `native`:
+      # #== and #eql? below are full overrides that never call super and never
+      # read #native.
+      def native
+        self
+      end
+
       def text
         call("function() { return this.textContent }")
       end
@@ -21,10 +37,11 @@ module Capybara
         filter_text(call("function() { return this.textContent }"))
       end
 
-      # Lightpanda's innerText returns textContent verbatim (no rendering, so no
-      # hidden-descendant filtering). Walk descendants ourselves, skipping nodes
-      # that fail VISIBLE_JS, and emit newlines around block-display elements
-      # (the part of innerText behavior we still need).
+      # Delegates to _lightpanda.visibleText, which gates on visibility (a
+      # not-visible element reads as "" — WebDriver semantics) and otherwise
+      # hands the rendered-text collection (block line breaks + display:none
+      # descendant skipping) to native innerText (#2785/#2795). We normalize the
+      # whitespace here to match Capybara's expected Chrome semantics.
       def visible_text
         call(VISIBLE_TEXT_JS).to_s
                              .gsub(/\A[[:space:]&&[^\u00A0]]+/, "")
@@ -69,14 +86,23 @@ module Capybara
         previous
       end
 
+      # Quiet form of the `isConnected` guard every other operation carries:
+      # true while the node is still attached to a live document, false once
+      # it has been detached or its document navigated away (mirrors Ferrum's
+      # `Node#exists?`, whose probe is `DOM.resolveNode`). Anything else that
+      # goes wrong still raises — only "gone" is turned into false.
+      def exists?
+        call("function() { return true; }")
+      rescue ObsoleteNode, NodeNotFoundError, NoExecutionContextError
+        false
+      end
+
+      # Routed through #call (not a bare call_function_on) so a detached
+      # host raises ObsoleteNode like every other node operation — Capybara's
+      # automatic_reload then re-finds the host instead of silently reading
+      # a stale shadowRoot.
       def shadow_root
-        result = driver.browser.with_default_context_wait do
-          driver.browser.call_function_on(
-            @remote_object_id,
-            "function() { return this.shadowRoot }",
-            return_by_value: false
-          )
-        end
+        result = call(SHADOW_ROOT_JS, return_by_value: false)
         return nil unless result.is_a?(Hash) && result["objectId"]
 
         self.class.new(driver, result["objectId"])
@@ -109,8 +135,15 @@ module Capybara
         call("function() { this.dispatchEvent(new MouseEvent('dblclick', {bubbles: true, cancelable: true})) }")
       end
 
+      # A real pointer entering an element fires `mouseover` (bubbling) AND
+      # `mouseenter` (non-bubbling), in that order. Dispatching only `mouseover`
+      # silently no-ops the `mouseenter->menu#open` Stimulus idiom and the
+      # Floating UI / tippy-style menus built on it — the dominant hover-menu
+      # pattern in Rails apps — so fire both. CSS `:hover` still reveals nothing
+      # (upstream tracks no pointer state); test/features/hover_test.rb pins
+      # both halves.
       def hover
-        call("function() { this.dispatchEvent(new MouseEvent('mouseover', {bubbles: true, cancelable: true})) }")
+        call(HOVER_JS)
       end
 
       # Kept as a deliberate no-op despite upstream now tracking scroll position
@@ -152,17 +185,29 @@ module Capybara
       end
 
       # Capybara's drag-and-drop API (`Element#drop`). String/Pathname arguments
-      # are file paths — read here and rebuilt as `File` objects in the page;
-      # Hash arguments are `{ mime_type => data }` string drops. We assemble a
-      # `DataTransfer` and fire `dragenter` -> `dragover` -> `drop` on this
-      # element, so HTML5 dropzones see the payload via `event.dataTransfer`.
+      # are file paths; Hash arguments are `{ mime_type => data }` string drops.
+      # We assemble a `DataTransfer` and fire `dragenter` -> `dragover` -> `drop`
+      # on this element, so HTML5 dropzones see the payload via
+      # `event.dataTransfer`.
+      #
+      # Files reach the page the way Cuprite's #316 does it: a hidden
+      # `<input type=file>` is attached to this element's document,
+      # `DOM.setFileInputFiles` points it at the paths (the browser reads the
+      # bytes off disk itself), and the drop JS moves `input.files` into the
+      # DataTransfer and removes the input. Previously the bytes were base64'd
+      # into the `Runtime.callFunctionOn` message, which capped a drop at
+      # ~70 MB under `--cdp-max-message-size` and pinned every byte in Ruby;
+      # now the size ceiling is Lightpanda's own file handling. Paths are read
+      # on the machine running Lightpanda (local for the spawned process),
+      # exactly like `attach_file`.
       #
       # DataTransfer/DataTransferItem/DragEvent landed upstream in PR #2671
       # (build ≥6699) and are guaranteed by the MINIMUM_NIGHTLY_BUILD floor;
       # without them the drop JS raises "DataTransfer is not defined".
       def drop(*args)
-        files, strings = partition_drop_args(args)
-        call(DROP_JS, files.to_json, strings.to_json)
+        paths, strings = partition_drop_args(args)
+        input = paths.empty? ? nil : attach_drop_input(paths)
+        call(DROP_JS, input, strings.to_json)
         nil
       end
 
@@ -171,15 +216,9 @@ module Capybara
       end
 
       def unselect_option
-        unless call("function() {
-          var s = this.parentElement;
-          while (s && (s.tagName || '').toUpperCase() !== 'SELECT') s = s.parentElement;
-          return !!(s && s.multiple);
-        }")
-          raise Capybara::UnselectNotAllowed, "Cannot unselect option from single select box."
-        end
+        return unless call(UNSELECT_OPTION_JS) == "not_multiple"
 
-        call(UNSELECT_OPTION_JS)
+        raise Capybara::UnselectNotAllowed, "Cannot unselect option from single select box."
       end
 
       def send_keys(*)
@@ -379,37 +418,26 @@ module Capybara
       # here and base64-encoded so binary content survives the JSON hop; Hashes
       # are `{ type => data }` string drops. Returns `[files, strings]`.
       def partition_drop_args(args)
-        files = []
+        paths = []
         strings = []
         args.each do |arg|
           if arg.is_a?(Hash)
             arg.each { |type, data| strings << { type: type.to_s, data: data.to_s } }
           else
-            path = arg.to_s
-            files << {
-              name: File.basename(path),
-              type: drop_mime_for(path),
-              b64: [File.binread(path)].pack("m0"),
-            }
+            paths << File.expand_path(arg.to_s)
           end
         end
-        [files, strings]
+        [paths, strings]
       end
 
-      # The dropzone handler only reads `file.name`, but real upload widgets key
-      # off `file.type`, so map the common upload extensions and fall back to a
-      # generic binary type.
-      DROP_MIME_TYPES = {
-        ".jpg" => "image/jpeg", ".jpeg" => "image/jpeg", ".png" => "image/png",
-        ".gif" => "image/gif", ".webp" => "image/webp", ".svg" => "image/svg+xml",
-        ".pdf" => "application/pdf", ".txt" => "text/plain", ".csv" => "text/csv",
-        ".json" => "application/json", ".html" => "text/html", ".xml" => "application/xml",
-        ".zip" => "application/zip",
-      }.freeze
-      private_constant :DROP_MIME_TYPES
-
-      def drop_mime_for(path)
-        DROP_MIME_TYPES.fetch(File.extname(path).downcase, "application/octet-stream")
+      # Hidden `<input type=file multiple>` in this element's own document (so
+      # drops inside an iframe stay in that frame's DOM), pre-loaded via
+      # DOM.setFileInputFiles. Returned as a Node so it can be bound as a
+      # callFunctionOn argument; DROP_JS removes it once the files are moved.
+      def attach_drop_input(paths)
+        oid = call(CREATE_DROP_INPUT_JS, return_by_value: false)["objectId"]
+        driver.browser.set_file_input_files(oid, paths)
+        self.class.new(driver, oid)
       end
 
       # Whitespace-normalized text (Cuprite pattern). Capybara's text matchers compare
@@ -437,22 +465,18 @@ module Capybara
       # a DOM mutation like `replaceWith`, the cached objectId still resolves
       # to the detached node, so reads succeed quietly and Capybara's
       # automatic_reload never re-runs the original query.
-      def call(function_declaration, *args)
+      def call(function_declaration, *args, return_by_value: true)
         guarded = wrap_with_attached_guard(function_declaration)
         driver.browser.with_default_context_wait do
-          driver.browser.call_function_on(@remote_object_id, guarded, *args)
+          driver.browser.call_function_on(@remote_object_id, guarded, *args,
+                                          return_by_value: return_by_value)
         end
       rescue JavaScriptError => e
         if e.message.include?(OBSOLETE_NODE_MARKER)
           raise ObsoleteNode.new(self, "Node is no longer attached to the document")
         end
 
-        case e.class_name
-        when "InvalidSelector"
-          raise InvalidSelector.new(e.message, nil, args.first)
-        else
-          raise
-        end
+        raise
       end
 
       OBSOLETE_NODE_MARKER = "LIGHTPANDA_OBSOLETE_NODE"
@@ -467,6 +491,18 @@ module Capybara
         JS
       end
 
+      # `mouseenter` carries `bubbles: false` per spec — it is dispatched on the
+      # target only, not walked up the ancestor chain the way a real pointer
+      # would. That covers the handler-on-the-hovered-element case (every
+      # Stimulus `mouseenter->` action) and stops short of emulating pointer
+      # geometry we don't have.
+      HOVER_JS = <<~JS
+        function() {
+          this.dispatchEvent(new MouseEvent('mouseover', {bubbles: true, cancelable: true}));
+          this.dispatchEvent(new MouseEvent('mouseenter', {bubbles: false, cancelable: true}));
+        }
+      JS
+
       # We dispatch a `MouseEvent` (not a generic `Event`) because Turbo's link
       # and form interceptors guard with `event instanceof MouseEvent` before
       # they consider intercepting — a synthetic `Event('click')` is silently
@@ -485,25 +521,57 @@ module Capybara
       CLICK_JS = <<~JS
         function() {
           var EventCtor = (typeof MouseEvent !== 'undefined') ? MouseEvent : Event;
+          // Emulate coordinate hit-testing without a layout engine. In a real
+          // browser a pointer click on a container lands on its frontmost
+          // descendant: THAT element is the event target, and the sequence
+          // bubbles UP from there (so the container's own handlers still fire).
+          // Lightpanda has no geometry — every rect is a hardcoded ~5x5, so
+          // document.elementFromPoint(center) just returns the container — so
+          // when `this` is a plain non-interactive wrapper we walk DOWN to the
+          // first visible child, repeatedly, stopping at the first element that
+          // is itself interactive or carries a click handler (onclick /
+          // role=button). That lands on the element a centered pointer would
+          // hit, so widgets that bind their handlers on an inner node fire:
+          // select2 v3 binds its open handler on the inner .select2-choice
+          // (single, mousedown) / .select2-choices (multi, click), the FIRST
+          // child of the .select2-container that Capybara helpers click. We
+          // can't use "single visible child" as a guard — select2 keeps an
+          // offscreen .select2-focusser <input> sibling that has no geometry to
+          // distinguish, so it reads as a second visible child. The descent
+          // never starts from an interactive element, so a normal
+          // button/link/input click still lands exactly on `this`.
+          var INTERACTIVE = { A: 1, BUTTON: 1, INPUT: 1, SELECT: 1, TEXTAREA: 1,
+                              OPTION: 1, LABEL: 1, SUMMARY: 1 };
+          var hit = this;
+          while (!INTERACTIVE[hit.tagName] &&
+                 !hit.hasAttribute('onclick') &&
+                 hit.getAttribute('role') !== 'button') {
+            var next = null, ch = hit.children;
+            for (var i = 0; i < ch.length; i++) {
+              if (!window._lightpanda || _lightpanda.isVisible(ch[i])) { next = ch[i]; break; }
+            }
+            if (!next) break;
+            hit = next;
+          }
           // Real pointer clicks are a mousedown -> mouseup -> click sequence,
           // and widgets like select2 open on `mousedown`, not `click`.
           // Cancelling mousedown suppresses focus/text-selection in a real
           // browser but never the click, so the click below is dispatched
           // unconditionally.
-          this.dispatchEvent(new EventCtor('mousedown', { bubbles: true, cancelable: true }));
-          this.dispatchEvent(new EventCtor('mouseup', { bubbles: true, cancelable: true }));
+          hit.dispatchEvent(new EventCtor('mousedown', { bubbles: true, cancelable: true }));
+          hit.dispatchEvent(new EventCtor('mouseup', { bubbles: true, cancelable: true }));
           var clickEvt = new EventCtor('click', { bubbles: true, cancelable: true });
-          var notCancelled = this.dispatchEvent(clickEvt);
+          var notCancelled = hit.dispatchEvent(clickEvt);
           if (!notCancelled || clickEvt.defaultPrevented) return;
-          var tag = this.tagName;
-          if (tag === 'A' && this.href && this.target !== '_blank') {
+          var tag = hit.tagName;
+          if (tag === 'A' && hit.href && hit.target !== '_blank') {
             // Same-document fragment-only navigation: just update hash (or do
             // nothing if identical). Mirrors Chrome — assigning location.href
             // to a same-document URL on Lightpanda triggers a real navigation
             // tick that cancels pending setTimeout callbacks and clears form
             // values, which breaks any test driving DOM updates from a click
             // handler on `<a href="#...">`.
-            var dest = new URL(this.href, document.baseURI);
+            var dest = new URL(hit.href, document.baseURI);
             var here = new URL(window.location.href);
             if (dest.origin === here.origin && dest.pathname === here.pathname &&
                 dest.search === here.search) {
@@ -511,7 +579,7 @@ module Capybara
                 window.location.hash = dest.hash;
               }
             } else {
-              window.location.href = this.href;
+              window.location.href = hit.href;
             }
           }
         }
@@ -544,17 +612,30 @@ module Capybara
         }
       JS
 
-      # Build a DataTransfer from the JSON payloads and replay the HTML5 drop
-      # sequence on this element. Files arrive base64-encoded and are rebuilt
-      # with `atob` (Blob accepts the binary string directly); string drops are
-      # added as typed items so the page can read them via getData/getAsString.
+      CREATE_DROP_INPUT_JS = <<~JS
+        function() {
+          var doc = this.ownerDocument || document;
+          var input = doc.createElement('input');
+          input.type = 'file';
+          input.multiple = true;
+          input.style.display = 'none';
+          input.setAttribute('data-lightpanda-drop-input', '');
+          (doc.body || doc.documentElement).appendChild(input);
+          return input;
+        }
+      JS
+
+      # Build a DataTransfer from the pre-loaded hidden input (files) and the
+      # JSON string payloads (typed items), then replay the HTML5 drop sequence
+      # on this element. The input is removed once its files are moved.
       DROP_JS = <<~JS
-        function(filesJson, stringsJson) {
+        function(input, stringsJson) {
           var el = this;
           var dt = new DataTransfer();
-          JSON.parse(filesJson).forEach(function(f) {
-            dt.items.add(new File([atob(f.b64)], f.name, { type: f.type }));
-          });
+          if (input) {
+            for (var i = 0; i < input.files.length; i++) dt.items.add(input.files[i]);
+            input.remove();
+          }
           JSON.parse(stringsJson).forEach(function(s) {
             dt.items.add(s.data, s.type);
           });
@@ -665,11 +746,14 @@ module Capybara
         }
       JS
 
+      # Returns 'not_multiple' (without mutating) when the owning <select>
+      # isn't multiple — Ruby raises Capybara::UnselectNotAllowed. One CDP
+      # round-trip instead of a separate ancestor-walk precheck.
       UNSELECT_OPTION_JS = <<~JS
         function() {
           var sel = this.parentElement;
           while (sel && (sel.tagName || '').toUpperCase() !== 'SELECT') sel = sel.parentElement;
-          if (!sel || !sel.multiple) return;
+          if (!sel || !sel.multiple) return 'not_multiple';
           this.selected = false;
           sel.dispatchEvent(new Event('input', {bubbles: true}));
           sel.dispatchEvent(new Event('change', {bubbles: true}));
@@ -682,13 +766,7 @@ module Capybara
         }
       JS
 
-      APPEND_KEYS_JS = <<~JS
-        function(key) {
-          this.focus();
-          this.value += key;
-          this.dispatchEvent(new Event('input', {bubbles: true}));
-        }
-      JS
+      SHADOW_ROOT_JS = "function() { return this.shadowRoot }"
 
       EDITABLE_HOST_JS = "function() { return _lightpanda.isContentEditable(this); }"
 
@@ -714,30 +792,57 @@ module Capybara
 
       OBSCURED_JS = "function() { return _lightpanda.isObscured(this); }"
 
+      # Capybara's contract for Element#path is an XPath that re-finds the very
+      # same node (`node #path returns xpath which points to itself`), so this
+      # emits `/HTML/BODY/DIV[2]/P[1]` rather than the CSS-ish
+      # `html > body > div:nth-of-type(2) > p` it used to. Chrome exposes no
+      # native equivalent either; Cuprite hand-rolls the same walk.
+      #
+      # Every step is indexed, including single children: `P[1]` and `P` select
+      # the same node, but the explicit index keeps the output stable if a
+      # sibling appears later, and it is what Chrome DevTools' "Copy XPath"
+      # produces. Positions count same-tag preceding siblings, which is exactly
+      # XPath's own positional semantics.
+      #
+      # No `id`-based shortcut: an `//*[@id="x"]` prefix is shorter but stops
+      # pointing at *this* node the moment the document has a duplicate id,
+      # which malformed real-world pages routinely do.
+      #
+      # An element inside a shadow root has no document-level XPath at all
+      # (XPath doesn't cross shadow boundaries, and a `/SPAN[1]` computed from
+      # the shadow tree would re-find some unrelated light-DOM node). Selenium's
+      # driver returns the sentinel string below in that case and Capybara's
+      # shared `node #path` spec pins it, so mirror it rather than emit a path
+      # that lies.
       GET_PATH_JS = <<~JS
         function() {
           var el = this;
-          var path = [];
+          if (el.getRootNode && typeof ShadowRoot !== 'undefined' && el.getRootNode() instanceof ShadowRoot) {
+            return '(: Shadow DOM element - no XPath :)';
+          }
+          var steps = [];
           while (el && el.nodeType === Node.ELEMENT_NODE) {
-            var selector = el.nodeName.toLowerCase();
-            if (el.id) {
-              selector += '#' + el.id;
-              path.unshift(selector);
-              break;
-            } else {
-              var sibling = el;
-              var nth = 1;
-              while (sibling = sibling.previousElementSibling) {
-                if (sibling.nodeName.toLowerCase() === el.nodeName.toLowerCase()) nth++;
-              }
-              if (nth > 1) selector += ':nth-of-type(' + nth + ')';
+            var name = el.nodeName.toUpperCase();
+            var index = 1;
+            var sibling = el;
+            while (sibling = sibling.previousElementSibling) {
+              if (sibling.nodeName.toUpperCase() === name) index++;
             }
-            path.unshift(selector);
-            el = el.parentNode;
+            steps.unshift(name + '[' + index + ']');
+            el = el.parentElement;
           }
-          return path.join(' > ');
+          return '/' + steps.join('/');
         }
       JS
+
+      # Internal wire format, not API — aligned with browser.rb's convention
+      # of private_constant for its JS snippets.
+      private_constant :CLICK_JS, :TRIGGER_JS, :DROP_JS, :CREATE_DROP_INPUT_JS, :SHADOW_ROOT_JS, :VISIBLE_JS,
+                       :VISIBLE_TEXT_JS,
+                       :PROPERTY_OR_ATTRIBUTE_JS, :GET_VALUE_JS, :SET_VALUE_JS,
+                       :IMPLICIT_SUBMIT_JS, :SELECT_OPTION_JS, :UNSELECT_OPTION_JS,
+                       :SET_CHECKBOX_JS, :EDITABLE_HOST_JS, :DISABLED_JS, :GET_STYLE_JS,
+                       :GET_RECT_JS, :OBSCURED_JS, :GET_PATH_JS
     end
   end
 end

data/lib/capybara/lightpanda/options.rb

@@ -20,10 +20,36 @@ module Capybara
       # `Capybara::Lightpanda.configure { |c| c.port = 9222 }` when external
       # tooling needs a known address.
       DEFAULT_PORT = 0
-      DEFAULT_WINDOW_SIZE = [1024, 768].freeze
+      # Mirrors Lightpanda's own `Viewport.default` (1920x1080) rather than
+      # Cuprite's 1024x768. window_size is applied for real now (see below), so
+      # a 1024x768 default would silently shrink the viewport of every existing
+      # suite and flip `@media` branches under them. Matching the browser's
+      # native default keeps `window_size` truthful AND leaves default
+      # behavior byte-identical to before it was wired up.
+      DEFAULT_WINDOW_SIZE = [1920, 1080].freeze
 
+      # window_size drives Emulation.setDeviceMetricsOverride via
+      # Browser#set_viewport on every create_page. This is a JS-visible
+      # viewport only — it sets window.innerWidth/innerHeight and the viewport
+      # that `matchMedia` / `@media` evaluate against, so responsive branches
+      # resolve at the size you ask for. It is NOT real layout: Lightpanda has
+      # no rendering engine, so getBoundingClientRect stays synthetic and
+      # nothing reflows. Sizing down will not make an off-viewport element
+      # report as obscured.
+      # headless is accepted for Cuprite drop-in compatibility but inert —
+      # headless is the only mode Lightpanda runs in.
+      # save_path: directory for downloaded files (Cuprite parity). nil falls
+      # back to Capybara.save_path at create_page time; downloads stay off when
+      # both are nil (Browser#create_page only opts in when a path exists).
+      # raise_on_unhandled_modal: a JS dialog that opens with no
+      # accept_modal/dismiss_modal pre-arm in flight is resolved by Lightpanda's
+      # silent default (confirm → cancel, prompt → null, alert → dismissed), so
+      # a runaway confirm cancels the action and the spec can still pass. false
+      # (default, Cuprite parity) warns on stderr; true raises
+      # UnhandledModalError from the action that opened it.
       attr_accessor :host, :port, :timeout, :handshake_timeout, :process_timeout,
-                    :window_size, :browser_path, :headless, :logger
+                    :window_size, :browser_path, :headless, :logger, :save_path,
+                    :raise_on_unhandled_modal
       attr_writer :ws_url
 
       def initialize(options = {})
@@ -32,9 +58,11 @@ module Capybara
         @timeout = options.fetch(:timeout, DEFAULT_TIMEOUT)
         @handshake_timeout = options.fetch(:handshake_timeout, DEFAULT_HANDSHAKE_TIMEOUT)
         @process_timeout = options.fetch(:process_timeout, DEFAULT_PROCESS_TIMEOUT)
-        @window_size = options.fetch(:window_size, DEFAULT_WINDOW_SIZE)
+        @window_size = validate_window_size(options.fetch(:window_size, DEFAULT_WINDOW_SIZE))
         @browser_path = options[:browser_path]
         @headless = options.fetch(:headless, true)
+        @save_path = options[:save_path]
+        @raise_on_unhandled_modal = options.fetch(:raise_on_unhandled_modal, false)
         @ws_url = options[:ws_url]
         @logger = parse_logger(options[:logger])
       end
@@ -58,6 +86,8 @@ module Capybara
           browser_path: browser_path,
           headless: headless,
           logger: logger,
+          save_path: save_path,
+          raise_on_unhandled_modal: raise_on_unhandled_modal,
         }
         h[:ws_url] = @ws_url if @ws_url
         h
@@ -65,6 +95,17 @@ module Capybara
 
       private
 
+      # Validated here rather than at apply time so a bad value fails before
+      # Browser#initialize spawns a Lightpanda process — raising later would
+      # orphan it. Upstream reads a 0 dimension as "keep the current one", so
+      # forwarding junk would half-apply a viewport instead of failing.
+      def validate_window_size(size)
+        width, height = size
+        return size if width.is_a?(Integer) && height.is_a?(Integer) && width.positive? && height.positive?
+
+        raise ArgumentError, "window_size must be [width, height] of positive Integers, got #{size.inspect}"
+      end
+
       def parse_logger(logger)
         return logger if logger.is_a?(Capybara::Lightpanda::Logger)
         return Capybara::Lightpanda::Logger.new(logger) if logger