robo_appian 0.0.2__py3-none-any.whl

robo_appian/__init__.py

@@ -0,0 +1,11 @@
+from robo_appian.utils.components.ButtonUtils import ButtonUtils
+from robo_appian.utils.components.ComponentUtils import ComponentUtils
+from robo_appian.utils.components.DateUtils import DateUtils
+from robo_appian.utils.components.DropdownUtils import DropdownUtils
+from robo_appian.utils.components.InputUtils import InputUtils
+from robo_appian.utils.components.LabelUtils import LabelUtils
+from robo_appian.utils.components.LinkUtils import LinkUtils
+from robo_appian.utils.components.TableUtils import TableUtils
+from robo_appian.utils.components.TabUtils import TabUtils
+
+__version__ = "0.1.0"

robo_appian/utils/components/ButtonUtils.py

@@ -0,0 +1,72 @@
+from selenium.webdriver.common.by import By
+from selenium.webdriver.support import expected_conditions as EC
+from selenium.webdriver.support.ui import WebDriverWait
+from selenium.webdriver.remote.webdriver import WebDriver
+
+class ButtonUtils:
+    """
+    Utility class for interacting with button elements in Selenium-based Appian UI automation.
+
+        Usage Example:
+
+        from selenium.webdriver.support.ui import WebDriverWait
+        from robo_appian.utils.components.ButtonUtils import ButtonUtils
+
+        wait = WebDriverWait(driver, 10)
+        ButtonUtils.click(wait, "Login")
+
+    """
+
+    @staticmethod
+    def find(wait: WebDriverWait, label: str):
+        """
+        Finds a button element by its label.
+
+        Parameters:
+            wait: Selenium WebDriverWait instance.
+            label: The visible text label of the button.
+
+        Returns:
+            The Selenium WebElement for the button.
+
+        Example:
+            ButtonUtils.find(wait, "Submit")
+
+        """
+
+        # This method locates a button that contains a span with the specified label text.
+
+        xpath = f".//button[./span[contains(translate(normalize-space(.), '\u00a0', ' '), '{label}')]]"
+        component = wait.until(EC.element_to_be_clickable((By.XPATH, xpath)))
+        return component
+
+    @staticmethod
+    def click(wait: WebDriverWait, label: str):
+        """
+        Clicks a button identified by its label.
+
+        Parameters:
+            wait: Selenium WebDriverWait instance.
+            label: The visible text label of the button.
+        Example:
+            ButtonUtils.click(wait, "Submit")
+
+        """
+        component = ButtonUtils.find(wait, label)
+        component.click()
+    @staticmethod
+    def clickInputButtonById(wait: WebDriverWait, id: str):
+        """
+        Finds and clicks an input button by its HTML id attribute.
+
+        Parameters:
+            wait: Selenium WebDriverWait instance.
+            id: The HTML id of the input button.
+
+        Example:
+            ButtonUtils.clickInputButtonById(wait, "button_id")
+
+        """
+        component = wait.until(EC.element_to_be_clickable((By.ID, id)))
+        component.click()
+        component.click()

robo_appian/utils/components/ComponentUtils.py

@@ -0,0 +1,289 @@
+from selenium.common.exceptions import NoSuchElementException
+from selenium.webdriver import ActionChains
+from selenium.webdriver.common.by import By
+from selenium.webdriver.common.keys import Keys
+from selenium.webdriver.support import expected_conditions as EC
+from selenium.webdriver.remote.webdriver import WebDriver
+from selenium.webdriver.support.ui import WebDriverWait
+
+
+class ComponentUtils:
+    """
+    Utility class for interacting with various components in Appian UI.
+
+    """
+
+    @staticmethod
+    def today():
+        """
+        Returns today's date formatted as MM/DD/YYYY.
+        """
+
+        from datetime import date
+
+        today = date.today()
+        yesterday_formatted = today.strftime("%m/%d/%Y")
+        return yesterday_formatted
+
+    @staticmethod
+    def yesterday():
+        """
+        Returns yesterday's date formatted as MM/DD/YYYY.
+        """
+
+        from datetime import date, timedelta
+
+        yesterday = date.today() - timedelta(days=1)
+        yesterday_formatted = yesterday.strftime("%m/%d/%Y")
+        return yesterday_formatted
+
+    # @staticmethod
+    # def find_dropdown_id(wait, dropdown_label):
+    #     label_class_name = "FieldLayout---field_label"
+    #     xpath = f'.//div/span[normalize-space(text())="{dropdown_label}" and @class="{label_class_name}"]'
+    #     span_element = wait.until(EC.presence_of_element_located((By.XPATH, xpath)))
+    #     span_element_id = span_element.get_attribute('id')
+    #     return span_element_id
+
+    # @staticmethod
+    # def find_input_id(wait, label_text):
+    #     label_class_name = "FieldLayout---field_label"
+    #     xpath = f'.//div/div/label[@class="{label_class_name}" and contains(normalize-space(text()), "{label_text}")]'
+    #     label_element = wait.until(EC.presence_of_element_located((By.XPATH, xpath)))
+    #     input_element_id = label_element.get_attribute('for')
+    #     return input_element_id
+
+    # @staticmethod
+    # def set_input_value(wait, label_text, value):
+    #     input_element_id = ComponentUtils.find_input_id(wait, label_text)
+    #     input_element = ComponentUtils.set_input_value_using_id(wait, input_element_id, value)
+    #     return input_element
+
+    # @staticmethod
+    # def set_input_value_using_id(wait, input_element_id, value):
+    #     input_element = wait.until(EC.presence_of_element_located((By.ID, input_element_id)))
+    #     input_element = wait.until(EC.element_to_be_clickable((By.ID, input_element_id)))
+    #     input_element.clear()
+    #     input_element.send_keys(value)
+    #     input_element.send_keys(Keys.RETURN)
+    #     return input_element
+
+    # @staticmethod
+    # def select_search_dropdown_value(wait, label, value):
+    #     span_element_id = ComponentUtils.find_dropdown_id(wait, label)
+    #     xpath = f'.//div[@id="{span_element_id}_value"]'
+    #     combobox = wait.until(EC.presence_of_element_located((By.XPATH, xpath)))
+    #     disabled = combobox.get_attribute("aria-disabled")
+    #     if disabled == "true":
+    #         return
+    #     aria_controls = combobox.get_attribute("aria-controls")
+    #     combobox = wait.until(EC.element_to_be_clickable((By.XPATH, xpath)))
+    #     combobox.click()
+
+    #     input_element_id = span_element_id + "_searchInput"
+    #     ComponentUtils.set_input_value_using_id(wait, input_element_id, value)
+
+    #     xpath = f'.//ul[@id="{aria_controls}"]/li[./div[normalize-space(text())="{value}"]]'
+    #     component = wait.until(EC.element_to_be_clickable((By.XPATH, xpath)))
+    #     component.click()
+
+    # @staticmethod
+    # def selectDropdownValue(wait, combobox, value):
+
+    #     aria_controls = combobox.get_attribute("aria-controls")
+    #     combobox.click()
+
+    #     xpath = f'.//div/ul[@id="{aria_controls}"]/li[./div[normalize-space(text())="{value}"]]'
+    #     component = wait.until(EC.presence_of_element_located((By.XPATH, xpath)))
+    #     component = wait.until(EC.element_to_be_clickable((By.XPATH, xpath)))
+    #     component.click()
+
+    # @staticmethod
+    # def select_dropdown_value(wait, label, value):
+    #     span_element_id = ComponentUtils.find_dropdown_id(wait, label)
+
+    #     xpath = f'.//div[@id="{span_element_id}_value"]'
+    #     combobox = wait.until(EC.element_to_be_clickable((By.XPATH, xpath)))
+    #     disabled = combobox.get_attribute("aria-disabled")
+    #     if disabled == "true":
+    #         return
+
+    #     combobox = wait.until(EC.element_to_be_clickable((By.XPATH, xpath)))
+    #     ComponentUtils.selectDropdownValue(wait, combobox, value)
+
+    # @staticmethod
+    # def findButton(wait, button_text):
+    #     xpath = f'.//button[.//span/span[contains(normalize-space(text()), "{button_text}")]]'
+    #     component = wait.until(EC.element_to_be_clickable((By.XPATH, xpath)))
+    #     return component
+
+    # @staticmethod
+    # def click_button(wait, button_text):
+    #     component = ComponentUtils.findButton(wait, button_text)
+    #     component.click()
+
+    # @staticmethod
+    # def select_tab(wait, tab_label_text):
+    #     xpath = f'.//div[@role="presentation"]/div/div/p[./span[normalize-space(text())="{tab_label_text}"]]'
+    #     component = wait.until(EC.element_to_be_clickable((By.XPATH, xpath)))
+    #     component.click()
+
+    @staticmethod
+    def findSuccessMessage(wait: WebDriverWait, message: str):
+        """
+        Finds a success message in the UI by its text.
+        Parameters:
+            wait: Selenium WebDriverWait instance.
+            message: The text of the success message to find.
+        Returns:
+            The Selenium WebElement for the success message.
+        Example:
+            ComponentUtils.findSuccessMessage(wait, "Operation completed successfully")
+        """
+        # This method locates a success message that contains a strong tag with the specified text.
+        # The message is normalized to handle any extra spaces.
+        # It uses the presence_of_element_located condition to ensure the element is present in the DOM.
+
+        xpath = f'.//div/div/p/span/strong[normalize-space(text())="{message}"]'
+        component = wait.until(EC.presence_of_element_located((By.XPATH, xpath)))
+        return component
+
+    @staticmethod
+    def findComponentUsingXpathAndClick(wait: WebDriverWait, xpath: str):
+        """
+        Finds a component using its XPath and clicks it.
+        Parameters:
+            wait: Selenium WebDriverWait instance.
+            xpath: The XPath of the component to find and click.
+        Example:
+            ComponentUtils.findComponentUsingXpathAndClick(wait, "//button[@id='submit']")
+
+        """
+        # This method locates a component using the provided XPath and clicks it.
+        # It uses the presence_of_element_located condition to ensure the element is present in the DOM.
+        # After locating the component, it clicks it to perform the action.
+        component = ComponentUtils.findComponentUsingXpath(wait, xpath)
+        component.click()
+
+    @staticmethod
+    def findComponentUsingXpath(wait: WebDriverWait, xpath: str):
+        """
+        Finds a component using its XPath.
+        Parameters:
+            wait: Selenium WebDriverWait instance.
+            xpath: The XPath of the component to find.
+        Returns:
+            The Selenium WebElement for the component.
+        Example:
+            ComponentUtils.findComponentUsingXpath(wait, "//button[@id='submit']")
+        """
+        # This method locates a component using the provided XPath.
+        # It uses the presence_of_element_located condition to ensure the element is present in the DOM.
+        # The method returns the WebElement for further interaction.
+        component = wait.until(EC.presence_of_element_located((By.XPATH, xpath)))
+        return component
+
+    @staticmethod
+    def checkComponentExistsByXpath(wait: WebDriverWait, xpath: str):
+        """
+        Checks if a component exists using its XPath.
+        Parameters:
+            wait: Selenium WebDriverWait instance.
+            xpath: The XPath of the component to check.
+        Returns:
+            True if the component exists, False otherwise.
+        Example:
+            ComponentUtils.checkComponentExistsByXpath(wait, "//button[@id='submit']")
+        """
+        # This method checks if a component exists by attempting to find it using the provided XPath.
+        # If the component is found, it returns True; otherwise, it catches the NoSuchElementException and returns False.
+        # It uses the presence_of_element_located condition to ensure the element is present in the DOM.
+
+        status = False
+        try:
+            ComponentUtils.findComponentUsingXpath(wait, xpath)
+            status = True
+        except NoSuchElementException:
+            pass
+
+        return status
+
+    @staticmethod
+    def checkComponentExistsById(driver: WebDriver, id: str):
+        """
+        Checks if a component exists using its ID.
+        Parameters:
+            driver: Selenium WebDriver instance.
+            id: The ID of the component to check.
+        Returns:
+            True if the component exists, False otherwise.
+        Example:
+            ComponentUtils.checkComponentExistsById(driver, "submit-button")
+        """
+        # This method checks if a component exists by attempting to find it using the provided ID.
+        # If the component is found, it returns True; otherwise, it catches the NoSuchElementException and returns False.
+        # It uses the find_element method to locate the element by its ID.
+
+        status = False
+        try:
+            driver.find_element(By.ID, id)
+            status = True
+        except NoSuchElementException:
+            pass
+
+        return status
+
+    @staticmethod
+    def findCount(wait: WebDriverWait, xpath: str):
+        """
+        Finds the count of components matching the given XPath.
+        Parameters:
+            wait: Selenium WebDriverWait instance.
+            xpath: The XPath of the components to count.
+        Returns:
+            The count of components matching the XPath.
+        Example:
+            count = ComponentUtils.findCount(wait, "//div[@class='item']")
+        """
+        # This method locates all components matching the provided XPath and returns their count.
+        # It uses the presence_of_all_elements_located condition to ensure all elements are present in the DOM.
+        # If no elements are found, it catches the NoSuchElementException and returns 0.
+
+        length = 0
+
+        try:
+            component = wait.until(
+                EC.presence_of_all_elements_located((By.XPATH, xpath))
+            )
+            length = len(component)
+        except NoSuchElementException:
+            pass
+
+        return length
+
+    # @staticmethod
+    # def findComponent(wait, label):
+    #     xpath = f".//div/label[text()='{label}']"
+    #     component = wait.until(EC.element_to_be_clickable((By.XPATH, xpath)))
+    #     component_id = component.get_attribute("for")
+
+    #     component = wait.until(EC.element_to_be_clickable((By.ID, component_id)))
+    #     return component
+
+    @staticmethod
+    def tab(driver: WebDriver):
+        """
+        Simulates a TAB key press in the browser.
+
+        Parameters:
+            driver: Selenium WebDriver instance.
+        Example:
+            ComponentUtils.tab(driver)
+        """
+        # This method simulates a TAB key press in the browser using ActionChains.
+        # It creates an ActionChains instance, sends the TAB key, and performs the action.
+        # This is useful for navigating through form fields or components in the UI.
+        # It uses the ActionChains class to perform the key press action.
+
+        actions = ActionChains(driver)
+        actions.send_keys(Keys.TAB).perform()

robo_appian/utils/components/DateUtils.py

@@ -0,0 +1,130 @@
+from selenium.webdriver.common.by import By
+from selenium.webdriver.support import expected_conditions as EC
+from selenium.webdriver.support.ui import WebDriverWait
+from selenium.webdriver.remote.webdriver import WebDriver
+from selenium.webdriver.remote.webelement import WebElement
+
+from robo_appian.utils.components.InputUtils import InputUtils
+
+
+class DateUtils:
+    """
+    Utility class for interacting with date components in Appian UI.
+
+        Usage Example:
+
+        # Set a date value
+        from robo_appian.utils.components.DateUtils import DateUtils
+        DateUtils.setDateValue(wait, "Start Date", "01/01/2024")
+
+    """
+
+    @staticmethod
+    def findComponent(wait: WebDriverWait, label: str):
+        """
+        Finds a date component by its label.
+
+        Parameters:
+            wait: Selenium WebDriverWait instance.
+            label: The visible text label of the date component.
+
+        Returns:
+            The Selenium WebElement for the date component.
+
+        Example:
+            DateUtils.findComponent(wait, "Start Date")
+
+        """
+
+        xpath = f".//div/label[text()='{label}']"
+        component: WebElement = wait.until(
+            EC.element_to_be_clickable((By.XPATH, xpath))
+        )
+        if not component:
+            raise ValueError(f"Could not find date component with label '{label}'.")
+
+        attribute: str = "for"
+        component_id = component.get_attribute(attribute)  # type: ignore[reportUnknownMemberType]
+        if component_id is None:
+            raise ValueError(
+                f"Could not find component using {attribute} attribute for label '{label}'."
+            )
+
+        component = wait.until(EC.element_to_be_clickable((By.ID, component_id)))
+        return component
+
+    @staticmethod
+    def setDateValue(wait: WebDriverWait, label: str, value: str):
+        """
+        Sets a date value in a date component identified by its label.
+
+        Parameters:
+            wait: Selenium WebDriverWait instance.
+            label: The visible text label of the date component.
+            value: The date value to set (e.g., "01/01/2024").
+
+        Returns:
+            The Selenium WebElement for the date component after setting the value.
+
+        Example:
+            DateUtils.setDateValue(wait, "Start Date", "01/01/2024")
+
+        """
+        # This method locates a date component that contains a label with the specified text.
+        # It then retrieves the component's ID and uses it to find the actual input element.
+        # component = wait.until(EC.element_to_be_clickable((By.XPATH, f".//div/label[text()='{label}']/following-sibling::input")))
+
+        component = DateUtils.findComponent(wait, label)
+        InputUtils.setValueUsingComponent(component, value)
+        return component
+
+    @staticmethod
+    def setDateValueAndSubmit(wait: WebDriverWait, label: str, value: str):
+        """
+        Sets a date value in a date component identified by its label and submits the form.
+
+        Parameters:
+            wait: Selenium WebDriverWait instance.
+            label: The visible text label of the date component.
+            value: The date value to set (e.g., "01/01/2024").
+
+        Returns:
+            The Selenium WebElement for the date component after setting the value.
+
+        Example:
+            DateUtils.setDateValueAndSubmit(wait, "Start Date", "01/01/2024")
+
+        """
+
+        # This method locates a date component that contains a label with the specified text.
+        # It then retrieves the component's ID and uses it to find the actual input element.
+        # It sets the value of the input element and submits it.
+
+        component = DateUtils.findComponent(wait, label)
+        InputUtils.setValueAndSubmitUsingComponent(component, value)
+
+        return component
+
+    @staticmethod
+    def click(wait: WebDriverWait, label: str):
+        """
+        Clicks on a date component identified by its label.
+
+        Parameters:
+            wait: Selenium WebDriverWait instance.
+            label: The visible text label of the date component.
+
+        Returns:
+            The Selenium WebElement for the date component after clicking.
+
+        Example:
+            DateUtils.click(wait, "Start Date")
+        """
+        # This method locates a date component that contains a label with the specified text.
+        # It then retrieves the component's ID and uses it to find the actual input element.
+        # It clicks on the input element to open the date picker.
+
+        component = DateUtils.findComponent(wait, label)
+        component.click()
+
+        return component

robo_appian/utils/components/DropdownUtils.py

@@ -0,0 +1,141 @@
+from selenium.webdriver.common.by import By
+from selenium.webdriver.support import expected_conditions as EC
+from selenium.webdriver.support.ui import WebDriverWait
+from selenium.webdriver.remote.webdriver import WebDriver
+from selenium.webdriver.remote.webelement import WebElement
+
+from robo_appian.utils.components.InputUtils import InputUtils
+
+
+class DropdownUtils:
+    """
+    Utility class for interacting with dropdown components in Appian UI.
+
+        Usage Example:
+
+        # Select a value from a dropdown
+        from robo_appian.utils.components.DropdownUtils import DropdownUtils
+        DropdownUtils.selectDropdownValue(wait, "Status", "Approved")
+
+        # Select a value from a search dropdown
+        from robo_appian.utils.components.DropdownUtils import DropdownUtils
+        DropdownUtils.selectSearchDropdownValue(wait, "Category", "Finance")
+    """
+
+    @staticmethod
+    def findDropdownEnabled(wait: WebDriverWait, dropdown_label: str):
+        """
+        Finds a dropdown component that is enabled and has the specified label.
+
+        Parameters:
+            wait: Selenium WebDriverWait instance.
+            dropdown_label: The visible text label of the dropdown component.
+
+        Returns:
+            The Selenium WebElement for the dropdown component.
+
+        Example:
+            DropdownUtils.findDropdownEnabled(wait, "Status")
+
+        """
+        # This method locates a dropdown component that contains a label with the specified text.
+        # It then retrieves the component's ID and uses it to find the actual dropdown element.
+        # The dropdown is identified by its role as a combobox and tabindex attribute.
+        # The XPath searches for a div that contains a span with the specified label text.
+        # It ensures that the dropdown is clickable and ready for interaction.
+        # The dropdown component is expected to have a structure where the label is within a span inside a div.
+
+        xpath = f'.//div[./div/span[normalize-space(text())="{dropdown_label}"]]/div/div/div/div[@role="combobox" and @tabindex="0"]'
+        component = wait.until(EC.element_to_be_clickable((By.XPATH, xpath)))
+        return component
+
+    @staticmethod
+    def selectValueUsingComponent(
+        wait: WebDriverWait, 
+        combobox: WebElement, 
+        value: str
+    ) -> None:
+        """
+        Selects a value from a dropdown component using the provided combobox element.
+
+        Parameters:
+            wait: Selenium WebDriverWait instance.
+            combobox: The Selenium WebElement for the combobox.
+            value: The value to select from the dropdown.
+
+        Example:
+            DropdownUtils.selectValueUsingComponent(wait, combobox, "Approved")
+
+        """
+        # This method assumes that the combobox is already found and passed as an argument.
+        # It retrieves the aria-controls attribute to find the dropdown list and selects the specified value.
+
+        if not combobox:
+            raise ValueError(f"Dropdown component object is not valid.")
+
+        component: WebElement = combobox.find_element(By.XPATH, "./div/div")  # type: ignore[reportUnknownMemberType]
+        aria_controls = component.get_attribute("aria-controls") # type: ignore[reportUnknownMemberType]
+        component.click()
+
+        xpath = f'.//div/ul[@id="{aria_controls}"]/li[./div[normalize-space(text())="{value}"]]'
+        # component = wait.until(EC.presence_of_element_located((By.XPATH, xpath)))
+        component = wait.until(EC.element_to_be_clickable((By.XPATH, xpath)))
+        component.click()
+
+    @staticmethod
+    def selectDropdownValue(wait: WebDriverWait, label: str, value: str) -> None:
+        """
+        Selects a value from a dropdown component identified by its label.
+
+        Parameters:
+            wait: Selenium WebDriverWait instance.
+            label: The visible text label of the dropdown component.
+            value: The value to select from the dropdown.
+
+        Example:
+            DropdownUtils.selectDropdownValue(wait, "Status", "Approved")
+
+        """
+        # This method finds the dropdown component by its label, retrieves the aria-controls attribute,
+        # and then clicks on the dropdown to display the options.
+
+        combobox = DropdownUtils.findDropdownEnabled(wait, label)
+        aria_controls = combobox.get_attribute("aria-controls") # type: ignore[reportUnknownMemberType]
+        combobox.click()
+
+        xpath = f'.//div/ul[@id="{aria_controls}"]/li[./div[normalize-space(text())="{value}"]]'
+        component = wait.until(EC.presence_of_element_located((By.XPATH, xpath)))
+        component = wait.until(EC.element_to_be_clickable((By.XPATH, xpath)))
+        component.click()
+
+    @staticmethod
+    def selectSearchDropdownValue(wait: WebDriverWait, dropdown_label: str, value: str):
+        """
+        Selects a value from a search-enabled dropdown component identified by its label.
+
+        Parameters:
+            wait: Selenium WebDriverWait instance.
+            dropdown_label: The visible text label of the search dropdown component.
+            value: The value to select from the dropdown.
+
+        Example:
+            DropdownUtils.selectSearchDropdownValue(wait, "Category", "Finance")
+
+        """
+        # This method finds the search-enabled dropdown component by its label, retrieves the aria-controls attribute
+        # and the component ID, clicks on the dropdown to display the search input,
+
+        component = DropdownUtils.findDropdownEnabled(wait, dropdown_label)
+        component_id = component.get_attribute("aria-labelledby") # type: ignore[reportUnknownMemberType]
+        aria_controls = component.get_attribute("aria-controls") # type: ignore[reportUnknownMemberType]
+        component.click()
+
+        input_component_id = str(component_id) + "_searchInput"
+        input_component = wait.until(
+            EC.element_to_be_clickable((By.ID, input_component_id))
+        )
+        InputUtils.setValueUsingComponent(input_component, value)
+
+        xpath = f'.//ul[@id="{aria_controls}"]/li[./div[normalize-space(text())="{value}"]][1]'
+        component = wait.until(EC.element_to_be_clickable((By.XPATH, xpath)))
+        component.click()