seleniumbase 4.44.2__py3-none-any.whl → 4.45.10__py3-none-any.whl

seleniumbase/fixtures/base_case.py

@@ -221,11 +221,28 @@ class BaseCase(unittest.TestCase):
                 [sys.executable, "-m", "pytest", file, "-s", *all_args]
             )
 
-    def open(self, url):
+    def open(self, url, **kwargs):
         """Navigates the current browser window to the specified page."""
         self.__check_scope()
         if self.__is_cdp_swap_needed():
-            self.cdp.open(url)
+            self.cdp.open(url, **kwargs)
+            return
+        elif (
+            getattr(self.driver, "_is_using_uc", None)
+            # and getattr(self.driver, "_is_using_auth", None)
+            and not getattr(self.driver, "_is_using_cdp", None)
+        ):
+            # Auth in UC Mode requires CDP Mode
+            # (and now we're always forcing it)
+            logging.info("open() in UC Mode now always activates CDP Mode.")
+            self.activate_cdp_mode(url, **kwargs)
+            return
+        elif (
+            getattr(self.driver, "_is_using_uc", None)
+            and getattr(self.driver, "_is_using_cdp", None)
+        ):
+            self.disconnect()
+            self.cdp.open(url, **kwargs)
             return
         self._check_browser()
         if self.__needs_minimum_wait():
@@ -1293,8 +1310,11 @@ class BaseCase(unittest.TestCase):
         self.__check_scope()
         return self.execute_script("return window.location.origin;")
 
-    def get_page_source(self):
-        if self.__is_cdp_swap_needed():
+    def get_html(self, *args, **kwargs):
+        return self.get_page_source(*args, **kwargs)
+
+    def get_page_source(self, *args, **kwargs):
+        if self.__is_cdp_swap_needed(*args, **kwargs):
             return self.cdp.get_page_source()
         self.wait_for_ready_state_complete()
         if self.__needs_minimum_wait:
@@ -1333,7 +1353,7 @@ class BaseCase(unittest.TestCase):
         if self.__is_cdp_swap_needed():
             self.cdp.go_back()
             return
-        if hasattr(self, "recorder_mode") and self.recorder_mode:
+        if getattr(self, "recorder_mode", None):
             self.save_recorded_actions()
         pre_action_url = None
         with suppress(Exception):
@@ -1361,7 +1381,7 @@ class BaseCase(unittest.TestCase):
         if self.__is_cdp_swap_needed():
             self.cdp.go_forward()
             return
-        if hasattr(self, "recorder_mode") and self.recorder_mode:
+        if getattr(self, "recorder_mode", None):
             self.save_recorded_actions()
         self.__last_page_load_url = None
         self.driver.forward()
@@ -1617,14 +1637,14 @@ class BaseCase(unittest.TestCase):
     def click_link_text(self, link_text, timeout=None):
         """This method clicks link text on a page."""
         self.__check_scope()
-        if self.__is_cdp_swap_needed():
-            self.cdp.find_element(link_text, timeout=timeout).click()
-            return
-        self.__skip_if_esc()
         if not timeout:
             timeout = settings.SMALL_TIMEOUT
         if self.timeout_multiplier and timeout == settings.SMALL_TIMEOUT:
             timeout = self.__get_new_timeout(timeout)
+        if self.__is_cdp_swap_needed():
+            self.cdp.find_element(link_text, timeout=timeout).click()
+            return
+        self.__skip_if_esc()
         link_text = self.__get_type_checked_text(link_text)
         if self.__is_cdp_swap_needed():
             self.cdp.click_link(link_text)
@@ -2697,7 +2717,7 @@ class BaseCase(unittest.TestCase):
         original_by = by
         selector, by = self.__recalculate_selector(selector, by)
         if self.__is_cdp_swap_needed():
-            self.cdp.gui_hover_element(selector)
+            self.cdp.hover_element(selector)
             return
         self.wait_for_element_visible(
             original_selector, by=original_by, timeout=timeout
@@ -2742,7 +2762,7 @@ class BaseCase(unittest.TestCase):
             click_selector, click_by
         )
         if self.__is_cdp_swap_needed():
-            self.cdp.gui_hover_and_click(hover_selector, click_selector)
+            self.cdp.hover_and_click(hover_selector, click_selector)
             return
         dropdown_element = self.wait_for_element_visible(
             original_selector, by=original_by, timeout=timeout
@@ -3426,6 +3446,46 @@ class BaseCase(unittest.TestCase):
             file_path = os.path.join(abs_path, html_file)
         self.open("file://" + file_path)
 
+    def evaluate(self, expression):
+        """Run a JavaScript expression and return the result."""
+        self.__check_scope()
+        if self.__is_cdp_swap_needed():
+            return self.cdp.evaluate(expression)
+        self._check_browser()
+        original_expression = expression
+        expression = expression.strip()
+        exp_list = expression.split("\n")
+        if exp_list and exp_list[-1].strip().startswith("return "):
+            expression = (
+                "\n".join(exp_list[0:-1]) + "\n"
+                + exp_list[-1].strip()[len("return "):]
+            ).strip()
+        evaluation = self.driver.execute_cdp_cmd(
+            "Runtime.evaluate",
+            {
+                "expression": expression
+            },
+        )
+        if "value" in evaluation["result"]:
+            return evaluation["result"]["value"]
+        elif evaluation["result"]["type"] == "undefined":
+            return None
+        elif "exceptionDetails" in evaluation:
+            raise Exception(evaluation["result"]["description"], expression)
+        elif evaluation["result"]["type"] == "object":
+            if "return " not in original_expression:
+                expression = "return " + original_expression.strip()
+            # Need to use execute_script() to return a WebDriver object.
+            # If this causes duplicate evaluation, don't use evaluate().
+            return self.execute_script(expression)
+        elif evaluation["result"]["type"] == "function":
+            return {}  # This is what sb.cdp.evaluate returns
+        elif "description" in evaluation["result"]:
+            # At this point, the description is the exception
+            raise Exception(evaluation["result"]["description"], expression)
+        else:  # Possibly an unhandled case if reached
+            return None
+
     def execute_script(self, script, *args, **kwargs):
         self.__check_scope()
         if self.__is_cdp_swap_needed():
@@ -3940,10 +4000,23 @@ class BaseCase(unittest.TestCase):
         Reverts self.set_content_to_frame()."""
         self.set_content_to_default(nested=True)
 
-    def open_new_window(self, switch_to=True):
+    def open_new_window(self, switch_to=True, **kwargs):
         """Opens a new browser tab/window and switches to it by default."""
+        url = None
+        if self.__looks_like_a_page_url(str(switch_to)):
+            # Different API for CDP Mode: First arg is a `url`.
+            # (Also, don't break backwards compat for reg mode)
+            url = switch_to
+            switch_to = True
         if self.__is_cdp_swap_needed():
-            self.cdp.open_new_tab(switch_to=switch_to)
+            self.cdp.open_new_tab(url=url, switch_to=switch_to, **kwargs)
+            return
+        elif (
+            getattr(self.driver, "_is_using_uc", None)
+            and getattr(self.driver, "_is_using_cdp", None)
+        ):
+            self.disconnect()
+            self.cdp.open_new_tab(url=url, switch_to=switch_to, **kwargs)
             return
         self.wait_for_ready_state_complete()
         if switch_to:
@@ -4694,7 +4767,7 @@ class BaseCase(unittest.TestCase):
         if not os.path.exists(file_path):
             os.makedirs(file_path)
         cookies_file_path = os.path.join(file_path, name)
-        cookies_file = open(cookies_file_path, "w+", encoding="utf-8")
+        cookies_file = open(cookies_file_path, mode="w+", encoding="utf-8")
         cookies_file.writelines(json_cookies)
         cookies_file.close()
 
@@ -4853,7 +4926,7 @@ class BaseCase(unittest.TestCase):
             self.driver.add_cookie(cookie)
 
     def __set_esc_skip(self):
-        if hasattr(self, "esc_end") and self.esc_end:
+        if getattr(self, "esc_end", None):
             script = (
                 """document.onkeydown = function(evt) {
                     evt = evt || window.event;
@@ -4871,7 +4944,7 @@ class BaseCase(unittest.TestCase):
             self.execute_script(script)
 
     def __skip_if_esc(self):
-        if hasattr(self, "esc_end") and self.esc_end:
+        if getattr(self, "esc_end", None):
             if self.execute_script("return document.sb_esc_end;") == "yes":
                 self.skip()
 
@@ -4893,8 +4966,7 @@ class BaseCase(unittest.TestCase):
         self.__disable_beforeunload_as_needed()
         if (
             self.page_load_strategy == "none"
-            and hasattr(settings, "SKIP_JS_WAITS")
-            and settings.SKIP_JS_WAITS
+            and getattr(settings, "SKIP_JS_WAITS", None)
         ):
             time.sleep(0.01)
             if self.undetectable:
@@ -4915,10 +4987,7 @@ class BaseCase(unittest.TestCase):
 
     def sleep(self, seconds):
         self.__check_scope()
-        if (
-            not hasattr(sb_config, "time_limit")
-            or (hasattr(sb_config, "time_limit") and not sb_config.time_limit)
-        ):
+        if not getattr(sb_config, "time_limit", None):
             time.sleep(seconds)
         elif seconds < 0.4:
             shared_utils.check_if_time_limit_exceeded()
@@ -4933,11 +5002,7 @@ class BaseCase(unittest.TestCase):
                 if now_ms >= stop_ms:
                     break
                 time.sleep(0.2)
-        if (
-            self.recorder_mode
-            and hasattr(sb_config, "record_sleep")
-            and sb_config.record_sleep
-        ):
+        if self.recorder_mode and getattr(sb_config, "record_sleep", None):
             time_stamp = self.execute_script("return Date.now();")
             origin = self.get_origin()
             action = ["sleep", seconds, origin, time_stamp]
@@ -4995,14 +5060,14 @@ class BaseCase(unittest.TestCase):
 
     def activate_cdp_mode(self, url=None, **kwargs):
         """Activate CDP Mode with the URL and kwargs."""
-        if hasattr(self.driver, "_is_using_uc") and self.driver._is_using_uc:
+        if getattr(self.driver, "_is_using_uc", None):
             if self.__is_cdp_swap_needed():
                 return  # CDP Mode is already active
             if not self.is_connected():
                 self.driver.connect()
             current_url = self.get_current_url()
             if not current_url.startswith(("about", "data", "chrome")):
-                self.open("about:blank")
+                self.driver.get("about:blank")
             self.driver.uc_open_with_cdp_mode(url, **kwargs)
         else:
             self.get_new_driver(undetectable=True)
@@ -5010,11 +5075,17 @@ class BaseCase(unittest.TestCase):
         self.cdp = self.driver.cdp
         if hasattr(self.cdp, "solve_captcha"):
             self.solve_captcha = self.cdp.solve_captcha
+        if hasattr(self.cdp, "click_captcha"):
+            self.click_captcha = self.cdp.click_captcha
+        if hasattr(self.cdp, "find_element_by_text"):
+            self.find_element_by_text = self.cdp.find_element_by_text
+        if getattr(self.driver, "_is_using_auth", None):
+            with suppress(Exception):
+                self.cdp.loop.run_until_complete(self.cdp.page.wait(0.25))
         self.undetectable = True
 
     def activate_recorder(self):
-        """Activate Recorder Mode on the current tab/window.
-        For persistent Recorder Mode, use the extension instead."""
+        """Activate Recorder Mode on the newest tab / window."""
         from seleniumbase.js_code.recorder_js import recorder_js
 
         if not self.is_chromium():
@@ -5027,7 +5098,7 @@ class BaseCase(unittest.TestCase):
                 "The %s Recorder is for Chromium only!\n"
                 "    (Supported browsers: Chrome and Edge)" % sc
             )
-        url = self.driver.current_url
+        url = self.get_current_url()
         if url.startswith(("data:", "about:", "chrome:", "edge:")):
             message = (
                 "The URL in Recorder-Mode cannot start with: "
@@ -5035,8 +5106,9 @@ class BaseCase(unittest.TestCase):
             )
             print("\n" + message)
             return
-        if self.recorder_ext:
+        if self.recorder_ext and not self.undetectable:
             return  # The Recorder extension is already active
+        self.switch_to_newest_tab()
         with suppress(Exception):
             recorder_on = self.get_session_storage_item("recorder_activated")
             if not recorder_on == "yes":
@@ -5659,14 +5731,13 @@ class BaseCase(unittest.TestCase):
         methodname = self._testMethodName
         context_filename = None
         if (
-            hasattr(sb_config, "is_context_manager")
-            and sb_config.is_context_manager
+            getattr(sb_config, "is_context_manager", None)
             and (filename == "base_case.py" or methodname == "runTest")
         ):
             import traceback
             stack_base = traceback.format_stack()[0].split(os.sep)[-1]
             test_base = stack_base.split(", in ")[0]
-            if hasattr(self, "cm_filename") and self.cm_filename:
+            if getattr(self, "cm_filename", None):
                 filename = self.cm_filename
             else:
                 filename = test_base.split('"')[0]
@@ -5683,7 +5754,7 @@ class BaseCase(unittest.TestCase):
                 classname = "MyTestClass"
             methodname = methodname.replace("[", "__").replace("]", "")
             methodname = re.sub(r"[\W]", "_", methodname)
-        if hasattr(self, "is_behave") and self.is_behave:
+        if getattr(self, "is_behave", None):
             classname = sb_config.behave_feature.name
             classname = classname.replace("/", " ").replace(" & ", " ")
             classname = re.sub(r"[^\w" + r"_ " + r"]", "", classname)
@@ -5751,7 +5822,7 @@ class BaseCase(unittest.TestCase):
         extra_file_name = "__init__.py"
         extra_file_path = os.path.join(recordings_folder, extra_file_name)
         if not os.path.exists(extra_file_path):
-            out_file = open(extra_file_path, "w+", "utf-8")
+            out_file = open(extra_file_path, mode="w+", encoding="utf-8")
             out_file.writelines("\r\n".join(data))
             out_file.close()
             sys.stdout.write("\nCreated recordings%s__init__.py" % os.sep)
@@ -5799,7 +5870,7 @@ class BaseCase(unittest.TestCase):
         extra_file_name = "pytest.ini"
         extra_file_path = os.path.join(recordings_folder, extra_file_name)
         if not os.path.exists(extra_file_path):
-            out_file = open(extra_file_path, "w+", "utf-8")
+            out_file = open(extra_file_path, mode="w+", encoding="utf-8")
             out_file.writelines("\r\n".join(data))
             out_file.close()
             sys.stdout.write("\nCreated recordings%spytest.ini" % os.sep)
@@ -5820,7 +5891,7 @@ class BaseCase(unittest.TestCase):
         extra_file_name = "setup.cfg"
         extra_file_path = os.path.join(recordings_folder, extra_file_name)
         if not os.path.exists(extra_file_path):
-            out_file = open(extra_file_path, "w+", "utf-8")
+            out_file = open(extra_file_path, mode="w+", encoding="utf-8")
             out_file.writelines("\r\n".join(data))
             out_file.close()
             sys.stdout.write("\nCreated recordings%ssetup.cfg" % os.sep)
@@ -5831,14 +5902,14 @@ class BaseCase(unittest.TestCase):
             test_id = sb_config._test_id
             file_name = test_id.split("::")[0].split("/")[-1].split("\\")[-1]
             file_name = file_name.split(".py")[0] + "_rec.py"
-        if hasattr(self, "is_behave") and self.is_behave:
+        if getattr(self, "is_behave", None):
             file_name = sb_config.behave_scenario.filename.replace(".", "_")
             file_name = file_name.split("/")[-1].split("\\")[-1] + "_rec.py"
             file_name = file_name
         elif context_filename:
             file_name = context_filename
         file_path = os.path.join(recordings_folder, file_name)
-        out_file = open(file_path, "w+", "utf-8")
+        out_file = open(file_path, mode="w+", encoding="utf-8")
         out_file.writelines("\r\n".join(data))
         out_file.close()
         rec_message = ">>> RECORDING SAVED as: "
@@ -5850,7 +5921,7 @@ class BaseCase(unittest.TestCase):
             if terminal_size > 30 and star_len > terminal_size:
                 star_len = terminal_size
         spc = "\n\n"
-        if hasattr(self, "rec_print") and self.rec_print:
+        if getattr(self, "rec_print", None):
             spc = ""
             sys.stdout.write("\nCreated recordings%s%s" % (os.sep, file_name))
             print()
@@ -5871,7 +5942,7 @@ class BaseCase(unittest.TestCase):
             rec_message = rec_message.replace(">>>", c2 + ">>>" + cr)
         print("%s%s%s%s%s\n%s" % (spc, rec_message, c1, file_path, cr, stars))
 
-        if hasattr(self, "rec_behave") and self.rec_behave:
+        if getattr(self, "rec_behave", None):
             # Also generate necessary behave-gherkin files.
             self.__process_recorded_behave_actions(srt_actions, colorama)
 
@@ -5882,7 +5953,7 @@ class BaseCase(unittest.TestCase):
         filename = self.__get_filename()
         feature_class = None
         scenario_test = None
-        if hasattr(self, "is_behave") and self.is_behave:
+        if getattr(self, "is_behave", None):
             feature_class = sb_config.behave_feature.name
             scenario_test = sb_config.behave_scenario.name
         else:
@@ -5936,11 +6007,11 @@ class BaseCase(unittest.TestCase):
                 os.makedirs(steps_folder)
 
         file_name = filename.split(".")[0]
-        if hasattr(self, "is_behave") and self.is_behave:
+        if getattr(self, "is_behave", None):
             file_name = sb_config.behave_scenario.filename.replace(".", "_")
         file_name = file_name.split("/")[-1].split("\\")[-1] + "_rec.feature"
         file_path = os.path.join(features_folder, file_name)
-        out_file = open(file_path, "w+", "utf-8")
+        out_file = open(file_path, mode="w+", encoding="utf-8")
         out_file.writelines("\r\n".join(data))
         out_file.close()
 
@@ -5953,7 +6024,7 @@ class BaseCase(unittest.TestCase):
             if terminal_size > 30 and star_len > terminal_size:
                 star_len = terminal_size
         spc = "\n"
-        if hasattr(self, "rec_print") and self.rec_print:
+        if getattr(self, "rec_print", None):
             spc = ""
             print()
             if " " not in file_path:
@@ -5978,7 +6049,7 @@ class BaseCase(unittest.TestCase):
         file_name = "__init__.py"
         file_path = os.path.join(features_folder, file_name)
         if not os.path.exists(file_path):
-            out_file = open(file_path, "w+", "utf-8")
+            out_file = open(file_path, mode="w+", encoding="utf-8")
             out_file.writelines("\r\n".join(data))
             out_file.close()
             print("Created recordings/features/__init__.py")
@@ -5991,7 +6062,7 @@ class BaseCase(unittest.TestCase):
         file_name = "behave.ini"
         file_path = os.path.join(features_folder, file_name)
         if not os.path.exists(file_path):
-            out_file = open(file_path, "w+", "utf-8")
+            out_file = open(file_path, mode="w+", encoding="utf-8")
             out_file.writelines("\r\n".join(data))
             out_file.close()
             print("Created recordings/features/behave.ini")
@@ -6030,7 +6101,7 @@ class BaseCase(unittest.TestCase):
         file_name = "environment.py"
         file_path = os.path.join(features_folder, file_name)
         if not os.path.exists(file_path):
-            out_file = open(file_path, "w+", "utf-8")
+            out_file = open(file_path, mode="w+", encoding="utf-8")
             out_file.writelines("\r\n".join(data))
             out_file.close()
             print("Created recordings/features/environment.py")
@@ -6040,7 +6111,7 @@ class BaseCase(unittest.TestCase):
         file_name = "__init__.py"
         file_path = os.path.join(steps_folder, file_name)
         if not os.path.exists(file_path):
-            out_file = open(file_path, "w+", "utf-8")
+            out_file = open(file_path, mode="w+", encoding="utf-8")
             out_file.writelines("\r\n".join(data))
             out_file.close()
             print("Created recordings/features/steps/__init__.py")
@@ -6051,7 +6122,7 @@ class BaseCase(unittest.TestCase):
         file_name = "imported.py"
         file_path = os.path.join(steps_folder, file_name)
         if not os.path.exists(file_path):
-            out_file = open(file_path, "w+", "utf-8")
+            out_file = open(file_path, mode="w+", encoding="utf-8")
             out_file.writelines("\r\n".join(data))
             out_file.close()
             print("Created recordings/features/steps/imported.py")
@@ -6278,7 +6349,12 @@ class BaseCase(unittest.TestCase):
         scroll - the option to scroll to the element first (Default: True)
         timeout - the time to wait for the element to appear """
         self.__check_scope()
-        if not self.__is_cdp_swap_needed():
+        if self.__is_cdp_swap_needed():
+            if page_utils.is_xpath_selector(selector):
+                if "contains(" in selector:
+                    self.cdp.highlight(selector)
+                    return
+        else:
             self._check_browser()
         self.__skip_if_esc()
         if isinstance(selector, WebElement):
@@ -6323,6 +6399,7 @@ class BaseCase(unittest.TestCase):
         By default, "html" will be used as the CSS Selector target.
         You can specify how many times in-a-row the action happens."""
         self.__check_scope()
+        self._check_browser()
         if times < 1:
             return
         element = self.wait_for_element_present(selector)
@@ -6345,6 +6422,7 @@ class BaseCase(unittest.TestCase):
         By default, "html" will be used as the CSS Selector target.
         You can specify how many times in-a-row the action happens."""
         self.__check_scope()
+        self._check_browser()
         if times < 1:
             return
         element = self.wait_for_element_present(selector)
@@ -6367,6 +6445,7 @@ class BaseCase(unittest.TestCase):
         By default, "html" will be used as the CSS Selector target.
         You can specify how many times in-a-row the action happens."""
         self.__check_scope()
+        self._check_browser()
         if times < 1:
             return
         element = self.wait_for_element_present(selector)
@@ -6389,6 +6468,7 @@ class BaseCase(unittest.TestCase):
         By default, "html" will be used as the CSS Selector target.
         You can specify how many times in-a-row the action happens."""
         self.__check_scope()
+        self._check_browser()
         if times < 1:
             return
         element = self.wait_for_element_present(selector)
@@ -7297,21 +7377,6 @@ class BaseCase(unittest.TestCase):
             with pip_find_lock:
                 with suppress(Exception):
                     shared_utils.make_writable(constants.PipInstall.FINDLOCK)
-                if sys.version_info < (3, 9):
-                    # Fix bug in newer cryptography for Python 3.7 and 3.8:
-                    # "pyo3_runtime.PanicException: Python API call failed"
-                    try:
-                        import cryptography
-                        if cryptography.__version__ != "39.0.2":
-                            del cryptography  # To get newer ver
-                            shared_utils.pip_install(
-                                "cryptography", version="39.0.2"
-                            )
-                            import cryptography
-                    except Exception:
-                        shared_utils.pip_install(
-                            "cryptography", version="39.0.2"
-                        )
                 try:
                     from pdfminer.high_level import extract_text
                 except Exception:
@@ -7603,7 +7668,11 @@ class BaseCase(unittest.TestCase):
                 destination_folder = constants.Files.DOWNLOADS_FOLDER
             if not os.path.exists(destination_folder):
                 os.makedirs(destination_folder)
-        page_utils._download_file_to(file_url, destination_folder)
+        agent = self.get_user_agent()
+        headers = {"user-agent": agent}
+        page_utils._download_file_to(
+            file_url, destination_folder, headers=headers
+        )
         if self.recorder_mode and self.__current_url_is_recordable():
             if self.get_session_storage_item("pause_recorder") == "no":
                 time_stamp = self.execute_script("return Date.now();")
@@ -7627,8 +7696,10 @@ class BaseCase(unittest.TestCase):
                 destination_folder = constants.Files.DOWNLOADS_FOLDER
             if not os.path.exists(destination_folder):
                 os.makedirs(destination_folder)
+        agent = self.get_user_agent()
+        headers = {"user-agent": agent}
         page_utils._download_file_to(
-            file_url, destination_folder, new_file_name
+            file_url, destination_folder, new_file_name, headers=headers
         )
 
     def save_data_as(self, data, file_name, destination_folder=None):
@@ -8740,6 +8811,9 @@ class BaseCase(unittest.TestCase):
         if self.timeout_multiplier and timeout == settings.LARGE_TIMEOUT:
             timeout = self.__get_new_timeout(timeout)
         selector, by = self.__recalculate_selector(selector, by)
+        if self.__is_cdp_swap_needed():
+            self.cdp.set_value(selector, text)
+            return
         self.wait_for_ready_state_complete()
         element = page_actions.wait_for_element_present(
             self.driver, selector, by, timeout
@@ -8760,10 +8834,14 @@ class BaseCase(unittest.TestCase):
         if self.timeout_multiplier and timeout == settings.LARGE_TIMEOUT:
             timeout = self.__get_new_timeout(timeout)
         selector, by = self.__recalculate_selector(selector, by)
-        self.wait_for_ready_state_complete()
-        element = page_actions.wait_for_element_present(
-            self.driver, selector, by, timeout
-        )
+        element = None
+        if self.__is_cdp_swap_needed():
+            element = self.cdp.select(selector, timeout=timeout)
+        else:
+            self.wait_for_ready_state_complete()
+            element = page_actions.wait_for_element_present(
+                self.driver, selector, by, timeout
+            )
         if element.tag_name.lower() in ["input", "textarea"]:
             self.js_update_text(selector, text, by=by, timeout=timeout)
             return
@@ -8955,7 +9033,7 @@ class BaseCase(unittest.TestCase):
                 self.__passed_then_skipped = True
             self.__will_be_skipped = True
             sb_config._results[test_id] = "Skipped"
-        if hasattr(self, "with_db_reporting") and self.with_db_reporting:
+        if getattr(self, "with_db_reporting", None):
             if self.is_pytest:
                 self.__skip_reason = reason
             else:
@@ -9226,9 +9304,9 @@ class BaseCase(unittest.TestCase):
         """Same as self.refresh_page()"""
         self.refresh_page()
 
-    def open_new_tab(self, switch_to=True):
+    def open_new_tab(self, switch_to=True, **kwargs):
         """Same as self.open_new_window()"""
-        self.open_new_window(switch_to=switch_to)
+        self.open_new_window(switch_to=switch_to, **kwargs)
 
     def switch_to_tab(self, tab, timeout=None):
         """Same as self.switch_to_window()
@@ -9253,81 +9331,42 @@ class BaseCase(unittest.TestCase):
         self, selector, text, by="css selector", timeout=None, retry=False
     ):
         """Same as self.update_text()"""
-        self.__check_scope()
-        if not timeout:
-            timeout = settings.LARGE_TIMEOUT
-        if self.timeout_multiplier and timeout == settings.LARGE_TIMEOUT:
-            timeout = self.__get_new_timeout(timeout)
-        selector, by = self.__recalculate_selector(selector, by)
         self.update_text(selector, text, by=by, timeout=timeout, retry=retry)
 
     def fill(
         self, selector, text, by="css selector", timeout=None, retry=False
     ):
         """Same as self.update_text()"""
-        self.__check_scope()
-        if not timeout:
-            timeout = settings.LARGE_TIMEOUT
-        if self.timeout_multiplier and timeout == settings.LARGE_TIMEOUT:
-            timeout = self.__get_new_timeout(timeout)
-        selector, by = self.__recalculate_selector(selector, by)
         self.update_text(selector, text, by=by, timeout=timeout, retry=retry)
 
     def write(
         self, selector, text, by="css selector", timeout=None, retry=False
     ):
         """Same as self.update_text()"""
-        self.__check_scope()
-        if not timeout:
-            timeout = settings.LARGE_TIMEOUT
-        if self.timeout_multiplier and timeout == settings.LARGE_TIMEOUT:
-            timeout = self.__get_new_timeout(timeout)
-        selector, by = self.__recalculate_selector(selector, by)
         self.update_text(selector, text, by=by, timeout=timeout, retry=retry)
 
     def click_link(self, link_text, timeout=None):
         """Same as self.click_link_text()"""
-        self.__check_scope()
-        if not timeout:
-            timeout = settings.SMALL_TIMEOUT
-        if self.timeout_multiplier and timeout == settings.SMALL_TIMEOUT:
-            timeout = self.__get_new_timeout(timeout)
         self.click_link_text(link_text, timeout=timeout)
 
     def click_partial_link(self, partial_link_text, timeout=None):
         """Same as self.click_partial_link_text()"""
-        self.__check_scope()
-        if not timeout:
-            timeout = settings.SMALL_TIMEOUT
-        if self.timeout_multiplier and timeout == settings.SMALL_TIMEOUT:
-            timeout = self.__get_new_timeout(timeout)
         self.click_partial_link_text(partial_link_text, timeout=timeout)
 
     def right_click(self, selector, by="css selector", timeout=None):
         """Same as self.context_click()"""
-        self.__check_scope()
-        if not timeout:
-            timeout = settings.SMALL_TIMEOUT
-        if self.timeout_multiplier and timeout == settings.SMALL_TIMEOUT:
-            timeout = self.__get_new_timeout(timeout)
         self.context_click(selector, by=by, timeout=timeout)
 
+    def hover_element(self, selector, by="css selector", timeout=None):
+        """Same as self.hover()"""
+        return self.hover(selector, by=by, timeout=timeout)
+
     def hover_on_element(self, selector, by="css selector", timeout=None):
         """Same as self.hover()"""
-        self.__check_scope()
-        if not timeout:
-            timeout = settings.SMALL_TIMEOUT
-        if self.timeout_multiplier and timeout == settings.SMALL_TIMEOUT:
-            timeout = self.__get_new_timeout(timeout)
         return self.hover(selector, by=by, timeout=timeout)
 
     def hover_over_element(self, selector, by="css selector", timeout=None):
         """Same as self.hover()"""
-        self.__check_scope()
-        if not timeout:
-            timeout = settings.SMALL_TIMEOUT
-        if self.timeout_multiplier and timeout == settings.SMALL_TIMEOUT:
-            timeout = self.__get_new_timeout(timeout)
         return self.hover(selector, by=by, timeout=timeout)
 
     def wait_for_element_visible(
@@ -9652,7 +9691,7 @@ class BaseCase(unittest.TestCase):
         To force a print during multithreaded tests, use: "sys.stderr.write()".
         To print without the new-line character end, use: "sys.stdout.write()".
         """
-        if hasattr(sb_config, "_multithreaded") and sb_config._multithreaded:
+        if getattr(sb_config, "_multithreaded", None):
             if not isinstance(msg, str):
                 with suppress(Exception):
                     msg = str(msg)
@@ -10091,6 +10130,21 @@ class BaseCase(unittest.TestCase):
         if self.timeout_multiplier and timeout == settings.SMALL_TIMEOUT:
             timeout = self.__get_new_timeout(timeout)
         if self.__is_cdp_swap_needed():
+            if self.demo_mode:
+                selector, by = self.__recalculate_selector(
+                    selector, by, xp_ok=False
+                )
+                a_t = "ASSERT"
+                if self._language != "English":
+                    from seleniumbase.fixtures.words import SD
+
+                    a_t = SD.translate_assert(self._language)
+                messenger_post = "<b>%s %s</b>: %s" % (
+                    a_t, by.upper(), selector
+                )
+                self.__highlight_with_assert_success(
+                    messenger_post, selector, by
+                )
             self.cdp.assert_element(selector, timeout=timeout)
             return True
         if isinstance(selector, list):
@@ -10385,6 +10439,20 @@ class BaseCase(unittest.TestCase):
                         messenger_post, selector, by
                     )
         elif self.__is_cdp_swap_needed():
+            if self.demo_mode:
+                a_t = "ASSERT TEXT"
+                i_n = "in"
+                if self._language != "English":
+                    from seleniumbase.fixtures.words import SD
+
+                    a_t = SD.translate_assert_text(self._language)
+                    i_n = SD.translate_in(self._language)
+                messenger_post = "<b>%s</b>: {%s} %s %s: %s" % (
+                    a_t, text, i_n, by.upper(), selector
+                )
+                self.__highlight_with_assert_success(
+                    messenger_post, selector, by
+                )
             self.cdp.assert_text(text, selector, timeout=timeout)
             return True
         elif self.__is_shadow_selector(selector):
@@ -11120,7 +11188,7 @@ class BaseCase(unittest.TestCase):
             return  # Skip the rest when deferred visual asserts are used
         the_html = visual_helper.get_sbs_html()
         file_path = os.path.join(test_logpath, constants.SideBySide.HTML_FILE)
-        out_file = open(file_path, "w+", encoding="utf-8")
+        out_file = open(file_path, mode="w+", encoding="utf-8")
         out_file.writelines(the_html)
         out_file.close()
 
@@ -11280,16 +11348,16 @@ class BaseCase(unittest.TestCase):
             self.save_screenshot(
                 baseline_png, visual_baseline_path, selector="body"
             )
-            out_file = open(page_url_file, "w+", encoding="utf-8")
+            out_file = open(page_url_file, mode="w+", encoding="utf-8")
             out_file.writelines(page_url)
             out_file.close()
-            out_file = open(level_1_file, "w+", encoding="utf-8")
+            out_file = open(level_1_file, mode="w+", encoding="utf-8")
             out_file.writelines(json.dumps(level_1))
             out_file.close()
-            out_file = open(level_2_file, "w+", encoding="utf-8")
+            out_file = open(level_2_file, mode="w+", encoding="utf-8")
             out_file.writelines(json.dumps(level_2))
             out_file.close()
-            out_file = open(level_3_file, "w+", encoding="utf-8")
+            out_file = open(level_3_file, mode="w+", encoding="utf-8")
             out_file.writelines(json.dumps(level_3))
             out_file.close()
 
@@ -11428,7 +11496,7 @@ class BaseCase(unittest.TestCase):
             alpha_n_d_name = "".join([x if x.isalnum() else "_" for x in name])
             side_by_side_name = "side_by_side_%s.html" % alpha_n_d_name
             file_path = os.path.join(test_logpath, side_by_side_name)
-            out_file = open(file_path, "w+", encoding="utf-8")
+            out_file = open(file_path, mode="w+", encoding="utf-8")
             out_file.writelines(the_html)
             out_file.close()
 
@@ -12120,7 +12188,7 @@ class BaseCase(unittest.TestCase):
             with suppress(Exception):
                 os.makedirs(saved_presentations_folder)
         file_path = os.path.join(saved_presentations_folder, filename)
-        out_file = open(file_path, "w+", encoding="utf-8")
+        out_file = open(file_path, mode="w+", encoding="utf-8")
         out_file.writelines(the_html)
         out_file.close()
         if self._output_file_saves:
@@ -12815,7 +12883,7 @@ class BaseCase(unittest.TestCase):
             with suppress(Exception):
                 os.makedirs(saved_charts_folder)
         file_path = os.path.join(saved_charts_folder, filename)
-        out_file = open(file_path, "w+", encoding="utf-8")
+        out_file = open(file_path, mode="w+", encoding="utf-8")
         out_file.writelines(the_html)
         out_file.close()
         if self._output_file_saves:
@@ -13874,7 +13942,7 @@ class BaseCase(unittest.TestCase):
                simulateClick(someLink);"""
             % css_selector
         )
-        if hasattr(self, "recorder_mode") and self.recorder_mode:
+        if getattr(self, "recorder_mode", None):
             self.save_recorded_actions()
         try:
             self.execute_script(script)
@@ -13922,7 +13990,7 @@ class BaseCase(unittest.TestCase):
                var someLink = arguments[0];
                simulateClick(someLink);"""
         )
-        if hasattr(self, "recorder_mode") and self.recorder_mode:
+        if getattr(self, "recorder_mode", None):
             self.save_recorded_actions()
         try:
             self.execute_script(script, element)
@@ -14129,7 +14197,7 @@ class BaseCase(unittest.TestCase):
         selector = self.convert_to_css_selector(selector, by=by)
         selector = self.__make_css_match_first_element_only(selector)
         click_script = """jQuery('%s')[0].click();""" % selector
-        if hasattr(self, "recorder_mode") and self.recorder_mode:
+        if getattr(self, "recorder_mode", None):
             self.save_recorded_actions()
         self.safe_execute_script(click_script)
 
@@ -14285,8 +14353,7 @@ class BaseCase(unittest.TestCase):
     def __needs_minimum_wait(self):
         if (
             self.page_load_strategy == "none"
-            and hasattr(settings, "SKIP_JS_WAITS")
-            and settings.SKIP_JS_WAITS
+            and getattr(settings, "SKIP_JS_WAITS", None)
         ):
             return True
         else:
@@ -14522,7 +14589,8 @@ class BaseCase(unittest.TestCase):
                 sb_config._virtual_display = self._xvfb_display
                 if "DISPLAY" not in os.environ.keys():
                     print(
-                        "\nX11 display failed! Will use regular xvfb!"
+                        "\n  X11 display failed! Is Xvfb installed? "
+                        "\n  Try this: `sudo apt install -y xvfb`"
                     )
                     self.__activate_standard_virtual_display()
                 else:
@@ -14535,7 +14603,10 @@ class BaseCase(unittest.TestCase):
                     print("\n" + str(e.msg))
                 else:
                     print(e)
-                print("\nX11 display failed! Will use regular xvfb!")
+                print(
+                    "\n  X11 display failed! Is Xvfb installed? "
+                    "\n  Try this: `sudo apt install -y xvfb`"
+                )
                 self.__activate_standard_virtual_display()
                 return
             pyautogui_is_installed = False
@@ -14614,10 +14685,7 @@ class BaseCase(unittest.TestCase):
 
     def __disable_beforeunload_as_needed(self):
         """Disables beforeunload as needed. Also resets frame_switch state."""
-        if (
-            hasattr(self, "_disable_beforeunload")
-            and self._disable_beforeunload
-        ):
+        if getattr(self, "_disable_beforeunload", None):
             self.disable_beforeunload()
         if self.recorder_mode:
             try:
@@ -15418,9 +15486,9 @@ class BaseCase(unittest.TestCase):
                 self.__skip_reason = None
                 self.testcase_manager.insert_testcase_data(data_payload)
                 self.case_start_time = int(time.time() * 1000.0)
-        elif hasattr(self, "is_behave") and self.is_behave:
+        elif getattr(self, "is_behave", None):
             self.__initialize_variables()
-        elif hasattr(self, "is_nosetest") and self.is_nosetest:
+        elif getattr(self, "is_nosetest", None):
             pass  # Setup performed in plugins for pynose
         else:
             # Pure Python run. (Eg. SB() and Driver() Managers)
@@ -15511,7 +15579,7 @@ class BaseCase(unittest.TestCase):
                 "Invalid input for Mobile Emulator device metrics!\n"
                 "Expecting a comma-separated string with integer values\n"
                 "for Width/Height, and an int or float for Pixel-Ratio.\n"
-                'Example: --metrics="411,731,3" '
+                'Example: --metrics="412,732,3" '
             )
             if len(metrics_list) != 3:
                 raise Exception(exception_string)
@@ -15612,7 +15680,7 @@ class BaseCase(unittest.TestCase):
                 )
                 raise Exception(message)
 
-        if not hasattr(self, "is_nosetest") or not self.is_nosetest:
+        if not getattr(self, "is_nosetest", None):
             # Xvfb Virtual Display activation for Linux
             self.__activate_virtual_display_as_needed()
 
@@ -15788,10 +15856,7 @@ class BaseCase(unittest.TestCase):
         self.__last_page_screenshot_png is for all screenshot log files."""
         SCREENSHOT_SKIPPED = constants.Warnings.SCREENSHOT_SKIPPED
         SCREENSHOT_UNDEFINED = constants.Warnings.SCREENSHOT_UNDEFINED
-        if (
-            hasattr(self, "no_screenshot_after_test")
-            and self.no_screenshot_after_test
-        ):
+        if getattr(self, "no_screenshot_after_test", None):
             from seleniumbase.core import encoded_images
 
             NO_SCREENSHOT = encoded_images.get_no_screenshot_png()
@@ -15822,10 +15887,7 @@ class BaseCase(unittest.TestCase):
                         ignore_test_time_limit=True,
                     )
                 try:
-                    if (
-                        hasattr(settings, "SCREENSHOT_WITH_BACKGROUND")
-                        and settings.SCREENSHOT_WITH_BACKGROUND
-                    ):
+                    if getattr(settings, "SCREENSHOT_WITH_BACKGROUND", None):
                         self.__last_page_screenshot = (
                             self.driver.get_screenshot_as_base64()
                         )
@@ -15896,11 +15958,10 @@ class BaseCase(unittest.TestCase):
         exc_message = None
         if (
             hasattr(self, "_outcome")
-            and hasattr(self._outcome, "errors")
-            and self._outcome.errors
+            and getattr(self._outcome, "errors", None)
         ):
             try:
-                exc_message = self._outcome.errors[0][1][1]
+                exc_message = self._outcome.errors[-1][1][1]
             except Exception:
                 exc_message = "(Unknown Exception)"
         else:
@@ -15985,8 +16046,7 @@ class BaseCase(unittest.TestCase):
     def __delay_driver_quit(self):
         delay_driver_quit = False
         if (
-            hasattr(self, "_using_sb_fixture")
-            and self._using_sb_fixture
+            getattr(self, "_using_sb_fixture", None)
             and "--pdb" in sys.argv
             and self.__has_exception()
             and len(self._drivers_list) == 1
@@ -16042,14 +16102,22 @@ class BaseCase(unittest.TestCase):
         has_exception = False
         if hasattr(sys, "last_traceback") and sys.last_traceback is not None:
             has_exception = True
-        elif hasattr(self, "is_context_manager") and self.is_context_manager:
+        elif getattr(self, "is_context_manager", None):
             if self.with_testing_base and self._has_failure:
                 return True
             else:
                 return False
         elif hasattr(self, "_outcome") and hasattr(self._outcome, "errors"):
-            if self._outcome.errors:
-                has_exception = True
+            if python3_11_or_newer:
+                if (
+                    self._outcome.errors
+                    and self._outcome.errors[-1]
+                    and self._outcome.errors[-1][1]
+                ):
+                    has_exception = True
+            else:
+                if self._outcome.errors:
+                    has_exception = True
         else:
             has_exception = sys.exc_info()[1] is not None
         if self.__will_be_skipped and hasattr(self, "_using_sb_fixture"):
@@ -16058,7 +16126,7 @@ class BaseCase(unittest.TestCase):
 
     def __get_test_id(self):
         """The id used in various places such as the test log path."""
-        if hasattr(self, "is_behave") and self.is_behave:
+        if getattr(self, "is_behave", None):
             file_name = sb_config.behave_scenario.filename
             file_name = file_name.replace("/", ".").replace("\\", ".")
             scenario_name = sb_config.behave_scenario.name
@@ -16068,7 +16136,7 @@ class BaseCase(unittest.TestCase):
             scenario_name = scenario_name.replace(" ", "_")
             test_id = "%s.%s" % (file_name, scenario_name)
             return test_id
-        elif hasattr(self, "is_context_manager") and self.is_context_manager:
+        elif getattr(self, "is_context_manager", None):
             if hasattr(self, "_manager_saved_id"):
                 self.__saved_id = self._manager_saved_id
             if self.__saved_id:
@@ -16080,7 +16148,7 @@ class BaseCase(unittest.TestCase):
                 import traceback
                 stack_base = traceback.format_stack()[0].split(os.sep)[-1]
                 test_base = stack_base.split(", in ")[0]
-                if hasattr(self, "cm_filename") and self.cm_filename:
+                if getattr(self, "cm_filename", None):
                     filename = self.cm_filename
                 else:
                     filename = test_base.split('"')[0]
@@ -16095,7 +16163,7 @@ class BaseCase(unittest.TestCase):
         )
         if self._sb_test_identifier and len(str(self._sb_test_identifier)) > 6:
             test_id = self._sb_test_identifier
-        elif hasattr(self, "_using_sb_fixture") and self._using_sb_fixture:
+        elif getattr(self, "_using_sb_fixture", None):
             test_id = sb_config._latest_display_id
         test_id = test_id.replace(".py::", ".").replace("::", ".")
         test_id = test_id.replace("/", ".").replace("\\", ".")
@@ -16117,7 +16185,7 @@ class BaseCase(unittest.TestCase):
                 return full_name.split("] ")[0] + "]"
             else:
                 return full_name.split(" ")[0]
-        if hasattr(self, "is_behave") and self.is_behave:
+        if getattr(self, "is_behave", None):
             return self.__get_test_id()
         test_id = "%s.%s.%s" % (
             self.__class__.__module__.split(".")[-1],
@@ -16138,7 +16206,7 @@ class BaseCase(unittest.TestCase):
                 return full_name.split("] ")[0] + "]"
             else:
                 return full_name.split(" ")[0]
-        if hasattr(self, "is_behave") and self.is_behave:
+        if getattr(self, "is_behave", None):
             file_name = sb_config.behave_scenario.filename
             line_num = sb_config.behave_line_num
             scenario_name = sb_config.behave_scenario.name
@@ -16171,7 +16239,7 @@ class BaseCase(unittest.TestCase):
         if "PYTEST_CURRENT_TEST" in os.environ:
             test_id = os.environ["PYTEST_CURRENT_TEST"].split(" ")[0]
             filename = test_id.split("::")[0].split("/")[-1]
-        elif hasattr(self, "is_behave") and self.is_behave:
+        elif getattr(self, "is_behave", None):
             filename = sb_config.behave_scenario.filename
             filename = filename.split("/")[-1].split("\\")[-1]
         else:
@@ -16207,8 +16275,7 @@ class BaseCase(unittest.TestCase):
             sb_config._pdb_failure = True
         elif (
             self.is_pytest
-            and hasattr(sb_config, "_pdb_failure")
-            and sb_config._pdb_failure
+            and getattr(sb_config, "_pdb_failure", None)
             and not has_exception
         ):
             return  # Handle case where "pytest --pdb" marks failures as Passed
@@ -16378,7 +16445,7 @@ class BaseCase(unittest.TestCase):
                     dash_pie = json.dumps(sb_config._saved_dashboard_pie)
                     dash_pie_loc = constants.Dashboard.DASH_PIE
                     pie_path = os.path.join(abs_path, dash_pie_loc)
-                    pie_file = open(pie_path, "w+", encoding="utf-8")
+                    pie_file = open(pie_path, mode="w+", encoding="utf-8")
                     pie_file.writelines(dash_pie)
                     pie_file.close()
         DASH_PIE_PNG_1 = constants.Dashboard.get_dash_pie_1()
@@ -16538,7 +16605,7 @@ class BaseCase(unittest.TestCase):
         )
         abs_path = os.path.abspath(".")
         file_path = os.path.join(abs_path, "dashboard.html")
-        out_file = open(file_path, "w+", encoding="utf-8")
+        out_file = open(file_path, mode="w+", encoding="utf-8")
         out_file.writelines(the_html)
         out_file.close()
         sb_config._dash_html = the_html
@@ -16551,7 +16618,7 @@ class BaseCase(unittest.TestCase):
             dash_json = json.dumps((_results, _display_id, _rt, _tlp, d_stats))
             dash_json_loc = constants.Dashboard.DASH_JSON
             dash_jsonpath = os.path.join(abs_path, dash_json_loc)
-            dash_json_file = open(dash_jsonpath, "w+", encoding="utf-8")
+            dash_json_file = open(dash_jsonpath, mode="w+", encoding="utf-8")
             dash_json_file.writelines(dash_json)
             dash_json_file.close()
 
@@ -16602,7 +16669,7 @@ class BaseCase(unittest.TestCase):
             self.__check_scope()
         except Exception:
             return
-        if hasattr(self, "recorder_mode") and self.recorder_mode:
+        if getattr(self, "recorder_mode", None):
             # In case tearDown() leaves the origin, save actions first.
             self.save_recorded_actions()
         if (
@@ -16797,7 +16864,7 @@ class BaseCase(unittest.TestCase):
         if not hasattr(self, "_using_sb_fixture") and self.__called_teardown:
             # This test already called tearDown()
             return
-        if hasattr(self, "recorder_mode") and self.recorder_mode:
+        if getattr(self, "recorder_mode", None):
             page_actions._reconnect_if_disconnected(self.driver)
             try:
                 self.__process_recorded_actions()
@@ -17032,7 +17099,7 @@ class BaseCase(unittest.TestCase):
                     self.testcase_manager.update_testcase_log_url(data_payload)
         else:
             # (Pynose / Behave / Pure Python)
-            if hasattr(self, "is_behave") and self.is_behave:
+            if getattr(self, "is_behave", None):
                 if sb_config.behave_scenario.status.name == "failed":
                     has_exception = True
                     sb_config._has_exception = True
@@ -17092,8 +17159,8 @@ class BaseCase(unittest.TestCase):
                     self._last_page_url = self.get_current_url()
                 except Exception:
                     self._last_page_url = "(Error: Unknown URL)"
-            if hasattr(self, "is_behave") and self.is_behave and has_exception:
-                if hasattr(sb_config, "pdb_option") and sb_config.pdb_option:
+            if getattr(self, "is_behave", None) and has_exception:
+                if getattr(sb_config, "pdb_option", None):
                     if (
                         hasattr(sb_config, "behave_step")
                         and hasattr(sb_config.behave_step, "exc_traceback")
@@ -17101,24 +17168,14 @@ class BaseCase(unittest.TestCase):
                         self.__activate_behave_post_mortem_debug_mode()
             if self._final_debug:
                 self.__activate_debug_mode_in_teardown()
-            elif (
-                hasattr(sb_config, "_do_sb_post_mortem")
-                and sb_config._do_sb_post_mortem
-            ):
+            elif getattr(sb_config, "_do_sb_post_mortem", None):
                 self.__activate_sb_mgr_post_mortem_debug_mode()
-            elif (
-                hasattr(sb_config, "_do_sb_final_trace")
-                and sb_config._do_sb_final_trace
-            ):
+            elif getattr(sb_config, "_do_sb_final_trace", None):
                 self.__activate_debug_mode_in_teardown()
             # (Pynose / Behave / Pure Python) Close all open browser windows
             self.__quit_all_drivers()
         # Resume tearDown() for all test runners, (Pytest / Pynose / Behave)
-        if (
-            hasattr(self, "_xvfb_display")
-            and self._xvfb_display
-            and not self._reuse_session
-        ):
+        if getattr(self, "_xvfb_display", None) and not self._reuse_session:
             # Stop the Xvfb virtual display launched from BaseCase
             try:
                 if hasattr(self._xvfb_display, "stop"):
@@ -17130,16 +17187,9 @@ class BaseCase(unittest.TestCase):
             except Exception:
                 pass
         if (
-            hasattr(sb_config, "_virtual_display")
-            and sb_config._virtual_display
+            getattr(sb_config, "_virtual_display", None)
             and hasattr(sb_config._virtual_display, "stop")
-            and (
-                not hasattr(sb_config, "reuse_session")
-                or (
-                    hasattr(sb_config, "reuse_session")
-                    and not sb_config.reuse_session
-                )
-            )
+            and not getattr(sb_config, "reuse_session", None)
         ):
             # CDP Mode may launch a 2nd Xvfb virtual display
             try: