seleniumbase 4.16.1__py3-none-any.whl → 4.16.3__py3-none-any.whl

seleniumbase/fixtures/base_case.py

@@ -1342,6 +1342,18 @@ class BaseCase(unittest.TestCase):
             self.driver, text, selector, by, self.browser
         )
 
+    def is_non_empty_text_visible(self, selector="html", by="css selector"):
+        """Returns whether the element has any non-empty text visible.
+        Whitespace-only text is considered empty text."""
+        self.wait_for_ready_state_complete()
+        time.sleep(0.01)
+        selector, by = self.__recalculate_selector(selector, by)
+        if self.__is_shadow_selector(selector):
+            return self.__is_shadow_non_empty_text_visible(selector)
+        return page_actions.is_non_empty_text_visible(
+            self.driver, selector, by=by
+        )
+
     def is_attribute_present(
         self, selector, attribute, value=None, by="css selector"
     ):
@@ -1450,9 +1462,8 @@ class BaseCase(unittest.TestCase):
                 else:
                     return None
         if hard_fail:
-            raise Exception(
-                "Partial Link text {%s} was not found!" % link_text
-            )
+            msg = "Partial Link text {%s} was not found!" % link_text
+            page_actions.timeout_exception("LinkTextNotFoundException", msg)
         else:
             return None
 
@@ -4826,6 +4837,7 @@ class BaseCase(unittest.TestCase):
         ext_actions.append("astnv")
         ext_actions.append("aetnv")
         ext_actions.append("as_et")
+        ext_actions.append("asnet")
         ext_actions.append("wf_el")
         ext_actions.append("sw_fr")
         ext_actions.append("sw_dc")
@@ -4852,6 +4864,7 @@ class BaseCase(unittest.TestCase):
         ext_actions.append("da_ep")
         ext_actions.append("da_te")
         ext_actions.append("da_et")
+        ext_actions.append("danet")
         ext_actions.append("pr_da")
         for n in range(len(srt_actions)):
             if srt_actions[n][0] in ext_actions:
@@ -8200,6 +8213,15 @@ class BaseCase(unittest.TestCase):
             original_selector=original_selector,
         )
 
+    def assert_link(self, link_text, timeout=None):
+        """Same as self.assert_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.assert_link_text(link_text, timeout=timeout)
+
     def assert_element_not_present(
         self, selector, by="css selector", timeout=None
     ):
@@ -8832,6 +8854,27 @@ class BaseCase(unittest.TestCase):
             self.driver, text, selector, by, timeout, self.browser
         )
 
+    def wait_for_non_empty_text_visible(
+        self, selector="html", by="css selector", timeout=None
+    ):
+        """Searches for any text in the element of the given selector.
+        Returns the element if it has visible text within the timeout.
+        Raises an exception if the element has no text within the timeout.
+        Whitespace-only text is considered empty 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)
+        if self.__is_shadow_selector(selector):
+            return self.__wait_for_non_empty_shadow_text_visible(
+                selector, timeout
+            )
+        return page_actions.wait_for_non_empty_text_visible(
+            self.driver, selector, by=by, timeout=timeout
+        )
+
     def wait_for_text(
         self, text, selector="html", by="css selector", timeout=None
     ):
@@ -8858,6 +8901,19 @@ class BaseCase(unittest.TestCase):
             text, selector, by=by, timeout=timeout
         )
 
+    def wait_for_non_empty_text(
+        self, selector="html", by="css selector", timeout=None
+    ):
+        """The shorter version of wait_for_non_empty_text_visible()"""
+        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)
+        return self.wait_for_non_empty_text_visible(
+            selector, by=by, timeout=timeout
+        )
+
     def find_text(
         self, text, selector="html", by="css selector", timeout=None
     ):
@@ -8884,6 +8940,19 @@ class BaseCase(unittest.TestCase):
             text, selector, by=by, timeout=timeout
         )
 
+    def find_non_empty_text(
+        self, selector="html", by="css selector", timeout=None
+    ):
+        """Same as wait_for_non_empty_text_visible() - returns the element"""
+        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)
+        return self.wait_for_non_empty_text_visible(
+            selector, by=by, timeout=timeout
+        )
+
     def assert_text_visible(
         self, text, selector="html", by="css selector", timeout=None
     ):
@@ -8988,6 +9057,48 @@ class BaseCase(unittest.TestCase):
                 self.__extra_actions.append(action)
         return True
 
+    def assert_non_empty_text(
+        self, selector="html", by="css selector", timeout=None
+    ):
+        """Assert that the element has any non-empty text visible.
+        Raises an exception if the element has no text within the timeout.
+        Whitespace-only text is considered empty 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)
+        original_selector = selector
+        selector, by = self.__recalculate_selector(selector, by)
+        if self.__is_shadow_selector(selector):
+            self.__assert_non_empty_shadow_text_visible(selector, timeout)
+            return True
+        self.wait_for_non_empty_text_visible(selector, by=by, timeout=timeout)
+        if self.demo_mode:
+            a_t = "ASSERT NON-EMPTY TEXT"
+            i_n = "in"
+            if self._language != "English":
+                from seleniumbase.fixtures.words import SD
+
+                a_t = SD.translate_assert_non_empty_text(self._language)
+                i_n = SD.translate_in(self._language)
+            messenger_post = "<b>%s</b> %s %s: %s" % (
+                a_t,
+                i_n,
+                by.upper(),
+                selector,
+            )
+            self.__highlight_with_assert_success(messenger_post, selector, by)
+        if self.recorder_mode and self.__current_url_is_recordable():
+            if self.get_session_storage_item("pause_recorder") == "no":
+                if by == By.XPATH:
+                    selector = original_selector
+                time_stamp = self.execute_script("return Date.now();")
+                origin = self.get_origin()
+                action = ["asnet", selector, origin, time_stamp]
+                self.__extra_actions.append(action)
+        return True
+
     ############
 
     def wait_for_link_text_present(self, link_text, timeout=None):
@@ -9009,11 +9120,11 @@ class BaseCase(unittest.TestCase):
                 if now_ms >= stop_ms:
                     break
                 time.sleep(0.2)
-        message = "Link text {%s} was not present after %s seconds!" % (
+        message = "Link text {%s} was not found after %s seconds!" % (
             link_text,
             timeout,
         )
-        page_actions.timeout_exception("NoSuchElementException", message)
+        page_actions.timeout_exception("LinkTextNotFoundException", message)
 
     def wait_for_partial_link_text_present(self, link_text, timeout=None):
         self.__check_scope()
@@ -9035,10 +9146,10 @@ class BaseCase(unittest.TestCase):
                     break
                 time.sleep(0.2)
         message = (
-            "Partial Link text {%s} was not present after %s seconds!"
+            "Partial Link text {%s} was not found after %s seconds!"
             "" % (link_text, timeout)
         )
-        page_actions.timeout_exception("NoSuchElementException", message)
+        page_actions.timeout_exception("LinkTextNotFoundException", message)
 
     def wait_for_link_text_visible(self, link_text, timeout=None):
         self.__check_scope()
@@ -10121,6 +10232,49 @@ class BaseCase(unittest.TestCase):
             self.__add_deferred_assert_failure(fs=fs)
             return False
 
+    def deferred_assert_non_empty_text(
+        self,
+        selector="html",
+        by="css selector",
+        timeout=None,
+        fs=False,
+    ):
+        """A non-terminating assertion for non-empty element text.
+        Failures will be saved until the process_deferred_asserts()
+        method is called from inside a test, likely at the end of it.
+        If "fs" is set to True, a failure screenshot is saved to the
+        "latest_logs/" folder for that assertion failure. Otherwise,
+        only the last page screenshot is taken for all failures when
+        calling the process_deferred_asserts() method."""
+        self.__check_scope()
+        if not timeout:
+            timeout = settings.MINI_TIMEOUT
+        if self.timeout_multiplier and timeout == settings.MINI_TIMEOUT:
+            timeout = self.__get_new_timeout(timeout)
+        self.__deferred_assert_count += 1
+        try:
+            url = self.get_current_url()
+            if url == self.__last_url_of_deferred_assert:
+                timeout = 0.6  # Was already on page (full wait not needed)
+            else:
+                self.__last_url_of_deferred_assert = url
+        except Exception:
+            pass
+        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();")
+                origin = self.get_origin()
+                action = ["danet", selector, origin, time_stamp]
+                self.__extra_actions.append(action)
+        try:
+            self.wait_for_non_empty_text_visible(
+                selector, by=by, timeout=timeout
+            )
+            return True
+        except Exception:
+            self.__add_deferred_assert_failure(fs=fs)
+            return False
+
     def deferred_check_window(
         self,
         name="default",
@@ -10217,6 +10371,18 @@ class BaseCase(unittest.TestCase):
             text=text, selector=selector, by=by, timeout=timeout, fs=fs
         )
 
+    def delayed_assert_non_empty_text(
+        self,
+        selector="html",
+        by="css selector",
+        timeout=None,
+        fs=False,
+    ):
+        """Same as self.deferred_assert_non_empty_text()"""
+        return self.deferred_assert_non_empty_text(
+            selector=selector, by=by, timeout=timeout, fs=fs
+        )
+
     def delayed_check_window(
         self,
         name="default",
@@ -13223,7 +13389,7 @@ class BaseCase(unittest.TestCase):
                 text,
                 selector,
             )
-            page_actions.timeout_exception("ElementNotVisibleException", msg)
+            page_actions.timeout_exception("TextNotVisibleException", msg)
         return True
 
     def __wait_for_exact_shadow_text_visible(self, text, selector, timeout):
@@ -13242,7 +13408,7 @@ class BaseCase(unittest.TestCase):
                         "" % (text, selector)
                     )
                     page_actions.timeout_exception(
-                        "ElementNotVisibleException", msg
+                        "TextNotVisibleException", msg
                     )
                 return True
             except Exception:
@@ -13257,7 +13423,32 @@ class BaseCase(unittest.TestCase):
                 "Expected exact text {%s} in element {%s} was not visible!"
                 % (text, selector)
             )
-            page_actions.timeout_exception("ElementNotVisibleException", msg)
+            page_actions.timeout_exception("TextNotVisibleException", msg)
+        return True
+
+    def __wait_for_non_empty_shadow_text_visible(self, selector, timeout):
+        start_ms = time.time() * 1000.0
+        stop_ms = start_ms + (settings.SMALL_TIMEOUT * 1000.0)
+        for x in range(int(settings.SMALL_TIMEOUT * 10)):
+            try:
+                actual_text = self.__get_shadow_text(selector, timeout=1)
+                actual_text = actual_text.strip()
+                if len(actual_text) == 0:
+                    msg = "Element {%s} has no visible text!" % (selector)
+                    page_actions.timeout_exception(
+                        "TextNotVisibleException", msg
+                    )
+                return True
+            except Exception:
+                now_ms = time.time() * 1000.0
+                if now_ms >= stop_ms:
+                    break
+                time.sleep(0.1)
+        actual_text = self.__get_shadow_text(selector, timeout=1)
+        actual_text = actual_text.strip()
+        if len(actual_text) == 0:
+            msg = "Element {%s} has no visible text!" % (selector)
+            page_actions.timeout_exception("TextNotVisibleException", msg)
         return True
 
     def __assert_shadow_text_visible(self, text, selector, timeout):
@@ -13312,6 +13503,31 @@ class BaseCase(unittest.TestCase):
             except Exception:
                 pass
 
+    def __assert_non_empty_shadow_text_visible(self, selector, timeout, strip):
+        self.__wait_for_non_empty_shadow_text_visible(selector, timeout, strip)
+        if self.demo_mode:
+            a_t = "ASSERT NON-EMPTY TEXT"
+            i_n = "in"
+            by = By.CSS_SELECTOR
+            if self._language != "English":
+                from seleniumbase.fixtures.words import SD
+
+                a_t = SD.translate_assert_non_empty_text(self._language)
+                i_n = SD.translate_in(self._language)
+            messenger_post = "<b>%s</b> %s %s: %s" % (
+                a_t,
+                i_n,
+                by.upper(),
+                selector,
+            )
+            try:
+                js_utils.activate_jquery(self.driver)
+                js_utils.post_messenger_success_message(
+                    self.driver, messenger_post, self.message_duration
+                )
+            except Exception:
+                pass
+
     def __is_shadow_element_present(self, selector):
         try:
             element = self.__get_shadow_element(selector, timeout=0.1)
@@ -13371,6 +13587,18 @@ class BaseCase(unittest.TestCase):
         except Exception:
             return False
 
+    def __is_shadow_non_empty_text_visible(self, selector):
+        try:
+            element = self.__get_shadow_element(selector, timeout=0.1)
+            if self.browser == "safari":
+                return (
+                    element.is_displayed()
+                    and len(element.get_attribute("innerText").strip() > 0)
+                )
+            return element.is_displayed() and len(element.text.strip()) > 0
+        except Exception:
+            return False
+
     def __is_shadow_attribute_present(self, selector, attribute, value=None):
         try:
             element = self.__get_shadow_element(selector, timeout=0.1)

seleniumbase/fixtures/page_actions.py

@@ -28,6 +28,7 @@ from selenium.common.exceptions import NoSuchElementException
 from selenium.common.exceptions import NoSuchWindowException
 from selenium.common.exceptions import StaleElementReferenceException
 from selenium.webdriver.common.action_chains import ActionChains
+from seleniumbase.common.exceptions import LinkTextNotFoundException
 from seleniumbase.common.exceptions import TextNotVisibleException
 from seleniumbase.config import settings
 from seleniumbase.fixtures import shared_utils
@@ -197,6 +198,38 @@ def is_attribute_present(
         return False
 
 
+def is_non_empty_text_visible(driver, selector, by="css selector"):
+    """
+    Returns whether the element has any text visible for the given selector.
+    @Params
+    driver - the webdriver object (required)
+    selector - the locator for identifying the page element (required)
+    by - the type of selector being used (Default: "css selector")
+    @Returns
+    Boolean (is any text visible in the element with the selector)
+    """
+    browser = None  # Only used for covering a Safari edge case
+    try:
+        if "safari:platformVersion" in driver.capabilities:
+            browser = "safari"
+    except Exception:
+        pass
+    try:
+        element = driver.find_element(by=by, value=selector)
+        element_text = element.text
+        if browser == "safari":
+            if element.tag_name.lower() in ["input", "textarea"]:
+                element_text = element.get_attribute("value")
+            else:
+                element_text = element.get_attribute("innerText")
+        elif element.tag_name.lower() in ["input", "textarea"]:
+            element_text = element.get_property("value")
+        element_text = element_text.strip()
+        return element.is_displayed() and len(element_text) > 0
+    except Exception:
+        return False
+
+
 def hover_on_element(driver, selector, by="css selector"):
     """
     Fires the hover event for the specified element by the given selector.
@@ -468,12 +501,12 @@ def wait_for_element_visible(
         )
         timeout_exception(ElementNotVisibleException, message)
     elif not element and by == "link text":
-        message = "Link text {%s} was not visible after %s second%s!" % (
+        message = "Link text {%s} was not found after %s second%s!" % (
             selector,
             timeout,
             plural,
         )
-        timeout_exception(ElementNotVisibleException, message)
+        timeout_exception(LinkTextNotFoundException, message)
     else:
         return element
 
@@ -870,12 +903,12 @@ def wait_for_element_clickable(
         )
         timeout_exception(ElementNotInteractableException, message)
     elif not element and by == "link text" and not is_visible:
-        message = "Link text {%s} was not visible after %s second%s!" % (
+        message = "Link text {%s} was not found after %s second%s!" % (
             selector,
             timeout,
             plural,
         )
-        timeout_exception(ElementNotVisibleException, message)
+        timeout_exception(LinkTextNotFoundException, message)
     elif not element and by == "link text" and is_visible:
         message = "Link text {%s} was not clickable after %s second%s!" % (
             selector,
@@ -1076,6 +1109,86 @@ def wait_for_exact_text_not_visible(
     timeout_exception(Exception, message)
 
 
+def wait_for_non_empty_text_visible(
+    driver, selector, by="css selector", timeout=settings.LARGE_TIMEOUT,
+):
+    """
+    Searches for any text in the element of the given selector.
+    Returns the element if it has visible text within the timeout.
+    Raises an exception if the element has no text within the timeout.
+    Whitespace-only text is considered empty text.
+    @Params
+    driver - the webdriver object (required)
+    text - the text that is being searched for in the element (required)
+    selector - the locator for identifying the page element (required)
+    by - the type of selector being used (Default: "css selector")
+    timeout - the time to wait for elements in seconds
+    @Returns
+    The web element object that has text
+    """
+    start_ms = time.time() * 1000.0
+    stop_ms = start_ms + (timeout * 1000.0)
+    element = None
+    visible = None
+    browser = None  # Only used for covering a Safari edge case
+    try:
+        if "safari:platformVersion" in driver.capabilities:
+            browser = "safari"
+    except Exception:
+        pass
+    for x in range(int(timeout * 10)):
+        shared_utils.check_if_time_limit_exceeded()
+        try:
+            element = None
+            visible = False
+            element = driver.find_element(by=by, value=selector)
+            if element.is_displayed():
+                visible = True
+            element_text = element.text
+            if browser == "safari":
+                if element.tag_name.lower() in ["input", "textarea"]:
+                    element_text = element.get_attribute("value")
+                else:
+                    element_text = element.get_attribute("innerText")
+            elif element.tag_name.lower() in ["input", "textarea"]:
+                element_text = element.get_property("value")
+            element_text = element_text.strip()
+            if element.is_displayed() and len(element_text) > 0:
+                return element
+        except Exception:
+            element = None
+        now_ms = time.time() * 1000.0
+        if now_ms >= stop_ms:
+            break
+        time.sleep(0.1)
+    plural = "s"
+    if timeout == 1:
+        plural = ""
+    if not element:
+        # The element does not exist in the HTML
+        message = "Element {%s} was not present after %s second%s!" % (
+            selector,
+            timeout,
+            plural,
+        )
+        timeout_exception(NoSuchElementException, message)
+    elif not visible:
+        # The element exists in the HTML, but is not visible
+        message = "Element {%s} was not visible after %s second%s!" % (
+            selector,
+            timeout,
+            plural,
+        )
+        timeout_exception(ElementNotVisibleException, message)
+    else:
+        # The element exists in the HTML, but has no visible text
+        message = (
+            "Element {%s} has no visible text after %s second%s!"
+            "" % (selector, timeout, plural)
+        )
+        timeout_exception(TextNotVisibleException, message)
+
+
 def wait_for_attribute_not_present(
     driver,
     selector,
@@ -1421,3 +1534,17 @@ def wait_for_text(
         timeout=timeout,
         browser=browser,
     )
+
+
+def wait_for_non_empty_text(
+    driver,
+    selector,
+    by="css selector",
+    timeout=settings.LARGE_TIMEOUT,
+):
+    return wait_for_non_empty_text_visible(
+        driver=driver,
+        selector=selector,
+        by=by,
+        timeout=timeout,
+    )

seleniumbase/fixtures/shared_utils.py

@@ -71,6 +71,7 @@ def format_exc(exception, message):
     from selenium.common.exceptions import NoSuchElementException
     from selenium.common.exceptions import NoSuchFrameException
     from selenium.common.exceptions import NoSuchWindowException
+    from seleniumbase.common.exceptions import LinkTextNotFoundException
     from seleniumbase.common.exceptions import NoSuchFileException
     from seleniumbase.common.exceptions import NoSuchOptionException
     from seleniumbase.common.exceptions import TextNotVisibleException
@@ -83,6 +84,10 @@ def format_exc(exception, message):
         exc = exceptions.ElementNotVisibleException
     elif exception == "ElementNotVisibleException":
         exc = exceptions.ElementNotVisibleException
+    elif exception == LinkTextNotFoundException:
+        exc = exceptions.LinkTextNotFoundException
+    elif exception == "LinkTextNotFoundException":
+        exc = exceptions.LinkTextNotFoundException
     elif exception == NoSuchElementException:
         exc = exceptions.NoSuchElementException
     elif exception == "NoSuchElementException":

seleniumbase/fixtures/words.py

@@ -38,7 +38,7 @@ class SD:
         words["French"] = "VÉRIFIER TEXTE"
         words["Italian"] = "VERIFICARE TESTO"
         words["Japanese"] = "テキストを確認する"
-        words["Korean"] = "텍스트 확인"
+        words["Korean"] = "텍스트 확인하는"
         words["Portuguese"] = "VERIFICAR TEXTO"
         words["Russian"] = "ПОДТВЕРДИТЬ ТЕКСТ"
         words["Spanish"] = "VERIFICAR TEXTO"
@@ -72,6 +72,20 @@ class SD:
         words["Spanish"] = "VERIFICAR TEXTO DEL ENLACE"
         return words[language]
 
+    def translate_assert_non_empty_text(language):
+        words = {}
+        words["English"] = "ASSERT NON-EMPTY TEXT"
+        words["Chinese"] = "断言非空文本"
+        words["Dutch"] = "CONTROLEREN NIET-LEGE TEKST"
+        words["French"] = "VÉRIFIER TEXTE NON VIDE"
+        words["Italian"] = "VERIFICARE TESTO NON VUOTO"
+        words["Japanese"] = "空ではないテキストを確認する"
+        words["Korean"] = "비어 있지 않은 텍스트 확인하는"
+        words["Portuguese"] = "VERIFICAR TEXTO NÃO VAZIO"
+        words["Russian"] = "ПОДТВЕРДИТЬ НЕПУСТОЙ ТЕКСТ"
+        words["Spanish"] = "VERIFICAR TEXTO NO VACÍO"
+        return words[language]
+
     def translate_assert_attribute(language):
         words = {}
         words["English"] = "ASSERT ATTRIBUTE"

seleniumbase/translate/chinese.py

@@ -77,6 +77,10 @@ class 硒测试用例(BaseCase):
         # assert_link_text(link_text)
         return self.assert_link_text(*args, **kwargs)
 
+    def 断言非空文本(self, *args, **kwargs):
+        # assert_non_empty_text(selector)
+        return self.assert_non_empty_text(*args, **kwargs)
+
     def 断言文本不可见(self, *args, **kwargs):
         # assert_text_not_visible(text, selector)
         return self.assert_text_not_visible(*args, **kwargs)

seleniumbase/translate/dutch.py

@@ -77,6 +77,10 @@ class Testgeval(BaseCase):
         # assert_link_text(link_text)
         return self.assert_link_text(*args, **kwargs)
 
+    def controleren_niet_lege_tekst(self, *args, **kwargs):
+        # assert_non_empty_text(selector)
+        return self.assert_non_empty_text(*args, **kwargs)
+
     def controleren_tekst_niet_zichtbaar(self, *args, **kwargs):
         # assert_text_not_visible(text, selector)
         return self.assert_text_not_visible(*args, **kwargs)

seleniumbase/translate/french.py

@@ -77,6 +77,10 @@ class CasDeBase(BaseCase):
         # assert_link_text(link_text)
         return self.assert_link_text(*args, **kwargs)
 
+    def vérifier_texte_non_vide(self, *args, **kwargs):
+        # assert_non_empty_text(selector)
+        return self.assert_non_empty_text(*args, **kwargs)
+
     def vérifier_texte_pas_affiché(self, *args, **kwargs):
         # assert_text_not_visible(text, selector)
         return self.assert_text_not_visible(*args, **kwargs)

seleniumbase/translate/italian.py

@@ -77,6 +77,10 @@ class CasoDiProva(BaseCase):
         # assert_link_text(link_text)
         return self.assert_link_text(*args, **kwargs)
 
+    def verificare_testo_non_vuoto(self, *args, **kwargs):
+        # assert_non_empty_text(selector)
+        return self.assert_non_empty_text(*args, **kwargs)
+
     def verificare_testo_non_visto(self, *args, **kwargs):
         # assert_text_not_visible(text, selector)
         return self.assert_text_not_visible(*args, **kwargs)

seleniumbase/translate/japanese.py

@@ -77,6 +77,10 @@ class セレニウムテストケース(BaseCase):
         # assert_link_text(link_text)
         return self.assert_link_text(*args, **kwargs)
 
+    def 空ではないテキストを確認する(self, *args, **kwargs):
+        # assert_non_empty_text(selector)
+        return self.assert_non_empty_text(*args, **kwargs)
+
     def テキが表示されていないことを確認します(self, *args, **kwargs):
         # assert_text_not_visible(text, selector)
         return self.assert_text_not_visible(*args, **kwargs)

seleniumbase/translate/korean.py

@@ -77,6 +77,10 @@ class 셀레늄_테스트_케이스(BaseCase):
         # assert_link_text(link_text)
         return self.assert_link_text(*args, **kwargs)
 
+    def 비어_있지_않은_텍스트_확인하는(self, *args, **kwargs):
+        # assert_non_empty_text(selector)
+        return self.assert_non_empty_text(*args, **kwargs)
+
     def 텍스트_보이지_않는지_확인(self, *args, **kwargs):
         # assert_text_not_visible(text, selector)
         return self.assert_text_not_visible(*args, **kwargs)