robotframework-apex 0.0.2__tar.gz → 0.0.3__tar.gz

{robotframework_apex-0.0.2 → robotframework_apex-0.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: robotframework-apex
-Version: 0.0.2
+Version: 0.0.3
 Summary: Robot Framework Browser extension library supporting Oracle APEX application using Page Object Model.
 Author: Maurice Koster
 Author-email: Maurice Koster <maurice@mauricekoster.com>
@@ -20,7 +20,7 @@ Requires-Dist: typer>=0.26.8
 Requires-Dist: jinja2>=3.1.6
 Requires-Dist: python-dotenv
 Requires-Dist: parsimonious>=0.11.0
-Requires-Dist: python-oracle-apex>=0.0.0
+Requires-Dist: python-oracle-apex>=0.0.1
 Requires-Python: >=3.13
 Description-Content-Type: text/markdown
 

{robotframework_apex-0.0.2 → robotframework_apex-0.0.3}/pyproject.toml

@@ -13,7 +13,7 @@ explicit = true
 
 [project]
 name = "robotframework-apex"
-version = "0.0.2"
+version = "0.0.3"
 dependencies = [
     "robotframework >= 7.1.1, < 9.0.0",
     "robotframework-browser >= 20.0.0, < 21.0.0",
@@ -23,7 +23,7 @@ dependencies = [
     "Jinja2 >= 3.1.6",
     "python-dotenv",
     "parsimonious>=0.11.0",
-    "python-oracle-apex>=0.0.0",
+    "python-oracle-apex>=0.0.1",
 ]
 requires-python = ">= 3.13"
 description = "Robot Framework Browser extension library supporting Oracle APEX application using Page Object Model."

{robotframework_apex-0.0.2 → robotframework_apex-0.0.3}/pyproject.toml.orig

@@ -8,7 +8,7 @@ module-name = "BrowserApex"
 [project]
 name = "robotframework-apex"
 
-version = "0.0.2"
+version = "0.0.3"
 dependencies = [
     "robotframework >= 7.1.1, < 9.0.0",
     "robotframework-browser >= 20.0.0, < 21.0.0",
@@ -18,7 +18,7 @@ dependencies = [
     "Jinja2 >= 3.1.6",
     "python-dotenv",
     "parsimonious>=0.11.0",
-    "python-oracle-apex>=0.0.0",
+    "python-oracle-apex>=0.0.1",
 ]
 
 

robotframework_apex-0.0.3/src/BrowserApex/browser.py

@@ -0,0 +1,320 @@
+"""
+Oracle APEX support
+"""
+
+from robot.libraries.BuiltIn import BuiltIn
+from robot.api.deco import  not_keyword, library
+from Browser import  SelectAttribute, ElementState, Browser
+from Browser.utils import PageLoadStates, logger
+from datetime import datetime
+
+from .keywords import (
+    Breadcrumb, 
+    ClassicReport,
+    Dialog, 
+    FieldCommand, 
+    LoginTemplate, 
+    Region, 
+    Tab
+)
+
+
+@library(scope='GLOBAL', auto_keywords=True)
+class BrowserApex(Browser):
+    def __init__(self, **kwargs):
+        if 'test_date_format' in kwargs:
+            self.test_date_format = kwargs['test_date_format']
+            del kwargs['test_date_format']
+        else:
+            self.test_date_format = '%m/%d/%Y'
+
+        Browser.__init__(self, **kwargs)
+
+        
+
+        self.container = None
+
+        self.field_input_callbacks = {
+            'TextField': self.fill_text_field,
+            'Textarea': self.fill_textarea_field,
+            'TextFieldwithautocomplete': self.fill_text_autocomplete_field,
+            'NumberField': self.fill_number_field,
+            'Password': self.fill_password_field,
+            'SelectList': self.fill_select_field,
+            'RadioGroup': self.fill_radio_group,
+            'DatePicker': self.fill_date_picker,
+            'PopupLOV': self.fill_popup_lov,
+        }
+        self.field_get_callbacks = {
+            'Hidden': self.get_value_hidden,
+            'DisplayOnly': self.get_value_displayonly
+        }
+        self.field_check_callbacks = {
+            'DisplayOnly': self.check_display_only,
+            'TextField': self.check_text_field,
+            'SelectList': self.check_select_list,
+            'DatePicker': self.check_date_picker,
+        }
+
+        self.locators = {}
+
+        self._field_commands = FieldCommand(self)
+                
+        self.add_library_components([
+            Breadcrumb(self),
+            ClassicReport(self),
+            Dialog(self),
+            self._field_commands,
+            LoginTemplate(self),
+            Region(self),
+            Tab(self),
+
+        ])
+        
+        
+    @not_keyword
+    def get_locator(self, locator_name, replace_strings={}):
+        locator = self.locators.get(locator_name)
+        for k, v in replace_strings.items():
+            locator = locator.replace(k, v)
+       
+        return locator
+
+
+ 
+    @not_keyword
+    def fill_text_field(self, field_name, field_id, value, field_args):
+        print(f"*INFO* Filling text field '{field_name}' with value: {value}")
+        element = self.get_element(f"{self.container} >> id={field_id}")
+        self.fill_text(element, str(value))
+
+    @not_keyword
+    def fill_text_autocomplete_field(self, field_name, field_id, value, field_args):
+        print(f"*INFO* Filling text field with autocomplete '{field_name}' with value: {value}")
+        element = self.get_element(f"{self.container} >> id={field_id} >> xpath=//input")
+        self.fill_text(element, str(value))
+
+    @not_keyword
+    def fill_textarea_field(self, field_name, field_id, value, field_args):
+        print(f"*INFO* Filling textarea field '{field_name}' with value: {value}")
+        element = self.get_element(f"{self.container} >> id={field_id}")
+        self.fill_text(element, str(value))
+
+    @not_keyword
+    def fill_number_field(self, field_name, field_id, value, field_args):
+        print(f"*INFO* Filling text field '{field_name}' with value: {value}")
+        element = self.get_element(f"{self.container} >> id={field_id}")
+        self.fill_text(element, str(value))
+
+    @not_keyword
+    def fill_password_field(self, field_name, field_id, value, field_args):
+        print(f"*INFO* Filling password field '{field_name}'")
+        element = self.get_element(f"{self.container} >> id={field_id}")
+        self.fill_text(element, value)
+
+    @not_keyword
+    def fill_select_field(self, field_name, field_id, value, field_args):
+        print(f"*INFO* Filling select field '{field_name}' with value: {value}")
+        element = self.get_element(f"{self.container} >> id={field_id}")
+        self.select_options_by(element, SelectAttribute.label, value)
+
+    @not_keyword
+    def fill_radio_group(self, field_name, field_id, value, field_args):
+        print(f"*INFO* Filling radio group '{field_name}' with value: {value}")
+        element = self.get_element(f"{self.container} >> id={field_id} >> xpath=//label[normalize-space(text())='{value}']")
+        self.click(element)
+        self.wait_for_elements_state(f"{self.container} >> id={field_id}", ElementState.stable)
+
+
+    @not_keyword
+    def fill_date_picker(self, field_name, field_id, value, field_args):
+        print(f"*INFO* Filling date picker '{field_name}' with value: {value}")
+        datepicker_element = self.get_element(f"{self.container} >> id={field_id}")
+        display_as = 'native'
+        attrs = self.get_attribute_names(datepicker_element)
+        if 'display-as' in attrs:
+            display_as = self.get_attribute(datepicker_element, 'display-as')
+
+        match display_as:
+            case 'native':
+                date_format = BuiltIn().get_variable_value("${datepicker_native_dateformat}", self.test_date_format)
+            case 'popup':
+                date_format = BuiltIn().get_variable_value("${datepicker_popup_dateformat}", self.test_date_format)
+            case _:
+                raise f"Unexpected 'display-as' attribute '{display_as}' of datapicker for {field_name}"
+        element = f"{datepicker_element} >> xpath=//input"
+        
+        d = datetime.strptime(value, self.test_date_format)
+        print(f"*INFO* datepicker variant: {display_as}. Using date format to type text: {date_format}")
+        self.type_text(element, d.strftime(format=date_format))
+        
+
+    @not_keyword
+    def fill_popup_lov(self, field_name, field_id, value, field_args):
+        print(f"*INFO* Filling popup '{field_name}' with value: {value} args: {field_args}")
+        # direct input = <id>
+        # popup button = <id>_lov_btn
+        element = self.get_element(f"{self.container} >> id={field_id}_lov_btn")
+        self.click(element)
+        self.wait_for_load_state(PageLoadStates.domcontentloaded, 1)
+
+        # zoeken zit buiten de dialog (in hoofdpagina) in de DOM
+        old_prefix = self.set_selector_prefix("")
+        
+        nr_retries = 5
+        while nr_retries > 0:
+            nr_retries -= 1
+            search_element = self.get_element(f'xpath=//div[contains(@class, "a-PopupLOV-dialog") and contains(@id, "{field_id}")] '
+                                                       '>> xpath=//input[@aria-label="Zoeken"]')
+            self.clear_text(search_element)
+            BuiltIn().sleep(1)
+            self.wait_for_load_state(PageLoadStates.networkidle, 10)
+            self.wait_for_load_state(PageLoadStates.domcontentloaded, 1)
+            
+            self.type_text(search_element, value)
+            BuiltIn().sleep(1)
+            self.wait_for_load_state(PageLoadStates.networkidle, 10)
+            self.wait_for_load_state(PageLoadStates.domcontentloaded, 1)
+
+            if 'manualentry' in field_args:
+                logger.info('PopupLOV: Entering manualentry')
+                search_element = self.get_element(f'xpath=//div[contains(@class, "a-PopupLOV-dialog") and contains(@id, "{field_id}")] '
+                                                           '>> xpath=//input[@aria-label="Zoeken"]')
+                self.press_keys(search_element, 'Enter')
+
+                self.wait_for_load_state(PageLoadStates.networkidle, 10)
+                self.wait_for_load_state(PageLoadStates.domcontentloaded, 1)
+
+            else:
+                # Wait for results, when expecting a row to match
+                old_mode = self.set_strict_mode(False)
+                self.wait_for_elements_state(f'xpath=//div[contains(@class, "a-PopupLOV-dialog") and contains(@id, "{field_id}")] '
+                                                    '>> xpath=//div[contains(@class, "a-PopupLOV-results")] '
+                                                    '>> xpath=//tbody/tr')
+                self.set_strict_mode(True)
+
+                elements = self.get_elements(f'xpath=//div[contains(@class, "a-PopupLOV-dialog") and contains(@id, "{field_id}")] '
+                                                '>> xpath=//div[contains(@class, "a-PopupLOV-results")]'
+                                                f'>> xpath=//tbody/tr')
+
+                if len(elements) > 0:
+                    element = elements[0]
+
+
+                self.click(element)
+                self.wait_for_load_state(PageLoadStates.domcontentloaded, 10)
+
+            states = self.get_element_states(f'xpath=//div[contains(@class, "a-PopupLOV-dialog") and contains(@id, "{field_id}")] '
+                                                            '>> xpath=//div[contains(@class, "a-PopupLOV-results")]')
+
+            if 'visible' not in states:
+                break
+
+            # TODO: try, until selected value holds in input
+
+        self.set_selector_prefix(old_prefix)
+
+  
+    @not_keyword
+    def fill_fields(self, locator, field_definition, data):
+        self.container = locator
+        for key, value in data.items():
+            if key in field_definition:
+                field = field_definition[key]
+                if ':' not in field:
+                    raise AssertionError(f"Field '{key}' has invalid definition: '{field}'")
+                field_id, field_type, *field_args = field.split(':')
+                print(f'*INFO* field_id: {field_id} field_type: {field_type} field_args: {field_args}')
+                cb = self.field_input_callbacks.get(field_type)
+
+                used_value = self._field_commands.process_command(value)
+
+                if used_value:
+                    if cb is None:
+                        raise RuntimeError(f"Field type {field_type} not supported")
+                    cb(key, field_id, used_value, field_args)
+
+                # set focus on container, to trigger validation on focus lost of field
+                self.focus(self.container)
+                self.wait_for_load_state(PageLoadStates.domcontentloaded, 1)
+        self.container = None
+
+
+    @not_keyword
+    def check_display_only(self, field_name, field_id, value):
+        print(f"*INFO* Checking DisplayOnly '{field_name}' with value: {value}")
+        element = self.get_element(f"{self.container} >> id={field_id}")
+        real_value = self.get_text(element)
+        BuiltIn().should_be_equal_as_strings(value, real_value, f"Field values not equal: {value} <-> {real_value}")
+        
+    @not_keyword
+    def check_text_field(self, field_name, field_id, value):
+        print(f"*INFO* Checking TextField '{field_name}' with value: {value}")
+        element = self.get_element(f"{self.container} >> id={field_id}")
+        real_value = self.get_text(element)
+        BuiltIn().should_be_equal_as_strings(value, real_value, f"Field values not equal: {value} <-> {real_value}")
+
+    @not_keyword
+    def check_select_list(self, field_name, field_id, value):
+        print(f"*INFO* Checking SelectList '{field_name}' with value: {value}")
+        element = self.get_element(f"{self.container} >> id={field_id}")
+        real_value = self.get_selected_options(element)
+        if len(real_value) != 1:
+            raise AssertionError("Expected 1 selected option")
+        BuiltIn().should_be_equal_as_strings(value, real_value[0], f"Field values not equal: {value} <-> {real_value}")
+    
+    @not_keyword
+    def check_date_picker(self, field_name, field_id, value):
+        print(f"*INFO* Checking DatePicker '{field_name}' with value: {value}")
+        element = self.get_element(f"{self.container} >> id={field_id} >> //input")
+        real_value = self.get_text(element)
+        BuiltIn().should_be_equal_as_strings(value, real_value, f"Field values not equal: {value} <-> {real_value}")
+    
+    @not_keyword
+    def check_fields(self, locator, field_definition, data):
+        self.container = locator
+        for key, value in data.items():
+            if key in field_definition:
+                field = field_definition[key]
+                if ':' not in field:
+                    raise AssertionError(f"Field '{key}' has invalid definition: '{field}'")
+                field_id, field_type, *field_args = field.split(':')
+                print(f'*INFO* field_id: {field_id} field_type: {field_type} field_args: {field_args}')
+                cb = self.field_check_callbacks.get(field_type)
+
+                used_value = self._field_commands.process_command(value)
+
+                if used_value:
+                    if cb is None:
+                        raise RuntimeError(f"Field type {field_type} not supported")
+                    cb(key, field_id, used_value)
+        self.container = None
+
+    @not_keyword
+    def get_value_hidden(self, field_id):
+        element = self.get_element(f"{self.container} >> id={field_id}")
+        value = self.get_text(element)
+        return value
+
+    @not_keyword
+    def get_value_displayonly(self, field_id):
+        element = self.get_element(f"{self.container} >> id={field_id}")
+        value = self.get_text(element)
+        return value
+
+    @not_keyword
+    def get_field_value(self, container, field_definition, field_name):
+        self.container = container
+        field = field_definition[field_name]
+        if ':' not in field:
+            raise AssertionError(f"Field '{field_name}' has invalid definition: '{field}'")
+        field_id, field_type, *field_args = field.split(':')
+        print(f'*INFO* field_id: {field_id} field_type: {field_type} field_args: {field_args}')
+        cb = self.field_get_callbacks.get(field_type)
+        if cb is None:
+            raise AttributeError(f"*WARN* No getter for field type: {field_type}")
+
+        value = cb(field_id)
+        print(f"*INFO* get value from: '{field_name}' of type '{field_type}'  returned: {value}")
+        self.container = None
+        return value

robotframework_apex-0.0.3/src/BrowserApex/keywords/__init__.py

@@ -0,0 +1,18 @@
+from .breadcrumb import Breadcrumb
+from .classicreport import ClassicReport
+from .dialog import Dialog
+from .field_commands import FieldCommand
+from .region import Region
+from .tabs import Tab
+from .login import LoginTemplate
+
+
+__all__ = [
+    "Breadcrumb",
+    "ClassicReport",
+    "Dialog",
+    "FieldCommand",
+    "LoginTemplate",
+    "Region",
+    "Tab"
+]

robotframework_apex-0.0.3/src/BrowserApex/keywords/breadcrumb.py

@@ -0,0 +1,32 @@
+from Browser import AssertionOperator
+from robot.libraries.BuiltIn import BuiltIn
+from Browser.utils import PageLoadStates, logger
+from robot.api.deco import keyword, not_keyword
+from ..librarycomponent import LibraryComponent
+
+
+class Breadcrumb(LibraryComponent):
+    """
+    Handling of Breadcrumb.
+    """
+    def __init__(self, library):
+        super().__init__(library)
+
+        self.library.locators.update({
+            'breadcrumb_container': "css=.t-BreadcrumbRegion",
+            'breadcrumb_button': "xpath=//button/span[contains(text(),'##TEXT##')]",
+        })
+
+    @keyword(tags=('Apex', 'Breadcrumb'))
+    def breadcrumb_button(self, button):
+        """
+        Click the button within the breadcrumb button region.
+        """
+        logger.info(f"Pressing button with text '{button}' in breadcrumb")
+
+        container = self.library.get_locator('breadcrumb_container') 
+        btn_locator = self.library.get_locator('breadcrumb_button', {'##TEXT##': button}) 
+
+        self.library.click(f"{container} >> {btn_locator}")
+        self.library.wait_for_load_state(PageLoadStates.networkidle, 10)
+        self.library.wait_for_load_state(PageLoadStates.domcontentloaded, 1)

robotframework_apex-0.0.3/src/BrowserApex/keywords/classicreport.py

@@ -0,0 +1,133 @@
+from Browser import AssertionOperator
+from robot.libraries.BuiltIn import BuiltIn
+from Browser.utils import PageLoadStates, logger
+from robot.api.deco import keyword, not_keyword
+from ..librarycomponent import LibraryComponent
+
+
+class ClassicReport(LibraryComponent):
+    """
+    Handling of Classic Report region.
+    """
+    def __init__(self, library):
+        super().__init__(library)
+
+        self.library.locators.update({
+            'report_container': "css=.t-Report",
+            'report_no_data_found': 'css=.nodatafound',
+            'report_table': "xpath=//table[@class='t-Report-report']",
+            'report_select_row': "xpath=//tbody/tr[##ROWNR##]",
+            'report_all_rows': "xpath=//tbody/tr",
+            'report_cell': "xpath=//td[@headers='##COL##']",
+        })
+
+        self.cell_check_callbacks = {
+            'PlainText': self.check_cell_plaintext
+        }
+
+
+    @not_keyword
+    def _get_report_locator(self, report):
+        if type(report) is str:
+            report_name = report
+        else:
+            if 'name' in report:
+                report_name = report['name']
+            else:
+                raise AttributeError("No name in report")
+
+        return self.library.get_locator('report_container', {'##NAME##': report_name})  
+
+    @not_keyword
+    def _check_report_visible(self, report, locator):
+        try:
+            element = self.library.get_element(f"{locator}")
+            self.library.get_element_states(element, AssertionOperator.contains, 'visible')
+        except:
+            raise AssertionError(f"Classic Report '{report}' not avaiable or visible")
+
+
+    @keyword(tags=('Apex', 'Classic Report'))
+    def select_report(self, report, parent=None):
+        if parent:
+            locator = self.library.get_element(f"{parent} >> {self._get_report_locator(report)}")
+        else:
+            locator = self.library.get_element(f"{self._get_report_locator(report)}")
+
+        self._check_report_visible(report, locator)
+        return locator
+
+    @keyword(tags=('Apex', 'Classic Report'))
+    def classic_report_select_row(self, locator, row_number):
+        table_locator = self.library.get_locator('report_table')
+        row_locator = self.library.get_locator('report_select_row', {"##ROWNR##": row_number})
+        self.library.click(f'{locator} >> {table_locator} >> {row_locator}')
+        self.library.wait_for_load_state(PageLoadStates.networkidle, 10)
+        self.library.wait_for_load_state(PageLoadStates.domcontentloaded, 1)
+
+
+    @not_keyword
+    def check_cell_plaintext(self, locator, column_name, column_id, value, *field_args):
+        logger.info(f"Checking PlainText '{column_name}' with value: {value}. Arguments: {field_args}")
+        cell_locator = self.library.get_locator('report_cell', {'##COL##': column_id})
+        self.library.get_text(locator + f" >> {cell_locator}", 
+                            AssertionOperator.equal, value)
+
+
+    @not_keyword
+    def _check_columns(self, locator, column_definition, data):
+        for key, value in data.items():
+            if key in column_definition:
+                field = column_definition[key]
+                if ':' not in field:
+                    raise AssertionError(f"Column '{key}' has invalid definition: '{field}'")
+                field_id, field_type, *field_args = field.split(':')
+                logger.info(f'field_id: {field_id} field_type: {field_type} field_args: {field_args}')
+                cb = self.cell_check_callbacks.get(field_type)
+
+                used_value = self.library._field_commands.process_command(value)
+
+                if used_value:
+                    if cb is None:
+                        raise RuntimeError(f"Column type {field_type} not supported")
+                    cb(locator, key, field_id, used_value, field_args)
+        
+    @keyword(tags=('Apex', 'Classic Report'))
+    def classic_report_check_row(self, locator, columns_definition, row_number, data):
+        table_locator = self.library.get_locator('report_table')
+        row_locator = self.library.get_locator('report_select_row', {"##ROWNR##": row_number})
+
+        container = f'{locator} >> {table_locator} >> {row_locator}'
+        self._check_columns(container, columns_definition, data)
+
+    @keyword(tags=('Apex', 'Classic Report'))
+    def classic_report_no_data_found(self, locator, message=None):
+        """
+        locator = Region
+
+        Check if region contains a Classic report, this is in case no data is found, there is no Classic Report.
+        """
+        msg_locator=self.library.get_locator('report_no_data_found')
+        elems = self.library.get_elements(f"{locator} >> {msg_locator}")
+        old_time_out = self.library.set_browser_timeout(1)
+        BuiltIn().should_be_equal_as_numbers(len(elems), 1, "no-data-found section not found. Unexpected Classic Report found.")
+        self.library.set_browser_timeout(old_time_out)
+
+        if message:
+            self.library.get_text(f"{locator} >> {msg_locator}", AssertionOperator.contains, message)
+
+    
+    @keyword(tags=('Apex', 'Classic Report'))
+    def classic_report_row_count(self, locator, expected_row_count=None):
+        self.library.wait_for_load_state(PageLoadStates.networkidle, 10)
+        self.library.wait_for_load_state(PageLoadStates.domcontentloaded, 1)
+        table_locator = self.library.get_locator('report_table')
+        row_locator = self.library.get_locator('report_all_rows')
+        
+        row_elements = self.library.get_elements(f'{locator} >> {table_locator} >> {row_locator}')
+        count = len(row_elements)
+        if expected_row_count is not None:
+            BuiltIn().should_be_equal_as_numbers(count, int(expected_row_count), "Number of report rows incorrect")
+        return count
+
+        

robotframework_apex-0.0.3/src/BrowserApex/keywords/dialog.py

@@ -0,0 +1,66 @@
+from Browser import AssertionOperator
+from robot.libraries.BuiltIn import BuiltIn
+from Browser.utils import PageLoadStates, logger, ElementState
+from robot.api.deco import keyword, not_keyword
+from ..librarycomponent import LibraryComponent
+
+
+class Dialog(LibraryComponent):
+    """
+    Handling of Dialogs.
+    """
+    def __init__(self, library):
+        super().__init__(library)
+
+        self.library.locators.update({
+            'dialog_container': "xpath=//div[@role='dialog']",
+            'dialog_container_by_title': "xpath=//div[@role='dialog' and @aria-label='##TITLE##']",
+            #'dialog_container': "css=.ui-dialog--apex",
+            'dialog_button': "xpath=//button/span[contains(text(),'##TEXT##')]",
+            'dialog_close_button': "xpath=//button[contains(@class, 'ui-dialog-titlebar-close')]",
+        })
+
+    @keyword(tags=('Apex', 'Dialog'))
+    def select_dialog(self, title, parent=None):
+        container = self.library.get_locator('dialog_container_by_title', {'##TITLE##': title}) 
+        if parent:
+            container = f"{parent} >> {container}"
+        self.library.wait_for_elements_state(container, ElementState.visible)
+        return container
+
+    @keyword(tags=('Apex', 'Dialog'))
+    def dialog_button(self, button):
+        """
+        Click the button within the dialog button region.
+        """
+        logger.info(f"Pressing button with text '{button}' in dialog")
+
+        container = self.library.get_locator('dialog_container') 
+        btn_locator = self.library.get_locator('dialog_button', {'##TEXT##': button}) 
+
+        btn = f"{container} >> {btn_locator}"
+        self.library.wait_for_elements_state(btn, ElementState.visible)
+
+        self.library.click(btn)
+        self.library.wait_for_load_state(PageLoadStates.networkidle, 10)
+        self.library.wait_for_load_state(PageLoadStates.domcontentloaded, 1)
+
+    @keyword(tags=('Apex', 'Dialog'))
+    def dialog_close(self):
+        """
+        Click the top-right close button of the dialog.
+        """
+        logger.info(f"Pressing the dialog close button.")
+
+
+        container = self.library.get_locator('dialog_container') 
+        btn_locator = self.library.get_locator('dialog_close_button') 
+
+        old_prefix = self.library.set_selector_prefix(None)
+        btn = f"{container} >> {btn_locator}"
+        # self.library.wait_for_elements_state(btn, ElementState.visible)
+
+        self.library.click(btn)
+        self.library.wait_for_load_state(PageLoadStates.networkidle, 10)
+        self.library.wait_for_load_state(PageLoadStates.domcontentloaded, 1)
+        self.library.set_selector_prefix(old_prefix)