OpenOrchestrator 1.3.1__py3-none-any.whl → 2.0.0rc2__py3-none-any.whl

OpenOrchestrator/tests/ui_tests/test_constants_tab.py

@@ -0,0 +1,167 @@
+"""Tests relating to the constants tab in Orchestrator."""
+
+import unittest
+import time
+
+from selenium.webdriver.common.by import By
+
+from OpenOrchestrator.tests import db_test_util
+from OpenOrchestrator.database import db_util
+from OpenOrchestrator.common import crypto_util
+from OpenOrchestrator.tests.ui_tests import ui_util
+
+
+class TestConstantsTab(unittest.TestCase):
+    """Test functionality of the constants tab ui."""
+    def setUp(self) -> None:
+        self.browser = ui_util.open_orchestrator()
+        db_test_util.establish_clean_database()
+        self.browser.find_element(By.CSS_SELECTOR, "[auto-id=constants_tab]").click()
+        ui_util.refresh_ui(self.browser)
+
+    def tearDown(self) -> None:
+        self.browser.quit()
+
+    @ui_util.screenshot_on_error
+    def test_constants_table(self):
+        """Test that constants are shown correctly in the constants table."""
+        db_util.create_constant("Constant 1", "Value 1")
+        db_util.create_constant("Constant 2", "Value 2")
+        ui_util.refresh_ui(self.browser)
+
+        table_data = ui_util.get_table_data(self.browser, "constants_tab_constants_table")
+
+        self.assertEqual(table_data[0][0], "Constant 1")
+        self.assertEqual(table_data[0][1], "Value 1")
+        self.assertRegex(table_data[0][2], r"\d{2}-\d{2}-\d{4} \d{2}:\d{2}:\d{2}")
+
+        self.assertEqual(table_data[1][0], "Constant 2")
+        self.assertEqual(table_data[1][1], "Value 2")
+        self.assertRegex(table_data[1][2], r"\d{2}-\d{2}-\d{4} \d{2}:\d{2}:\d{2}")
+
+    @ui_util.screenshot_on_error
+    def test_credentials_table(self):
+        """Test that credentials are shown correctly in the credentials table."""
+        db_util.create_credential("Credential 1", "Username 1", "abc")
+        db_util.create_credential("Credential 2", "Username 2", "abcdefghijklmnopq")
+        ui_util.refresh_ui(self.browser)
+
+        table_data = ui_util.get_table_data(self.browser, "constants_tab_credentials_table")
+
+        self.assertEqual(table_data[0][0], "Credential 1")
+        self.assertEqual(table_data[0][1], "Username 1")
+        self.assertEqual(table_data[0][2], "100 encrypted bytes. 0-15 decrypted bytes.")
+        self.assertRegex(table_data[0][3], r"\d{2}-\d{2}-\d{4} \d{2}:\d{2}:\d{2}")
+
+        self.assertEqual(table_data[1][0], "Credential 2")
+        self.assertEqual(table_data[1][1], "Username 2")
+        self.assertEqual(table_data[1][2], "120 encrypted bytes. 16-31 decrypted bytes.")
+        self.assertRegex(table_data[1][3], r"\d{2}-\d{2}-\d{4} \d{2}:\d{2}:\d{2}")
+
+    @ui_util.screenshot_on_error
+    def test_create_constant(self):
+        """Test creating a constant."""
+        self.browser.find_element(By.CSS_SELECTOR, "[auto-id=constants_tab_constant_button]").click()
+        self.browser.find_element(By.CSS_SELECTOR, "[auto-id=constant_popup_name_input]").send_keys("Constant Name")
+        self.browser.find_element(By.CSS_SELECTOR, "[auto-id=constant_popup_value_input]").send_keys("Constant Value")
+        self.browser.find_element(By.CSS_SELECTOR, "[auto-id=constant_popup_save_button]").click()
+        time.sleep(1)
+
+        constant = db_util.get_constant("Constant Name")
+        self.assertEqual(constant.name, "Constant Name")
+        self.assertEqual(constant.value, "Constant Value")
+
+    @ui_util.screenshot_on_error
+    def test_create_credential(self):
+        """Test creating a credential."""
+        self.browser.find_element(By.CSS_SELECTOR, "[auto-id=constants_tab_credential_button]").click()
+        self.browser.find_element(By.CSS_SELECTOR, "[auto-id=credential_popup_name_input]").send_keys("Credential Name")
+        self.browser.find_element(By.CSS_SELECTOR, "[auto-id=credential_popup_username_input]").send_keys("Credential Username")
+        self.browser.find_element(By.CSS_SELECTOR, "[auto-id=credential_popup_password_input]").send_keys("Credential Password")
+        self.browser.find_element(By.CSS_SELECTOR, "[auto-id=credential_popup_save_button]").click()
+        time.sleep(1)
+
+        # Make sure the encryption key matches the one in the ui
+        crypto_util.set_key(ui_util.ENCRYPTION_KEY)
+
+        credential = db_util.get_credential("Credential Name")
+        self.assertEqual(credential.name, "Credential Name")
+        self.assertEqual(credential.username, "Credential Username")
+        self.assertEqual(credential.password, "Credential Password")
+
+    @ui_util.screenshot_on_error
+    def test_edit_constant(self):
+        """Test editing an existing constant."""
+        # Create a constant
+        db_util.create_constant("Constant Name", "Value")
+        ui_util.refresh_ui(self.browser)
+
+        # Click constant in table
+        ui_util.click_table_row(self.browser, "constants_tab_constants_table", 0)
+
+        self.browser.find_element(By.CSS_SELECTOR, "[auto-id=constant_popup_value_input]").send_keys(" New")
+        self.browser.find_element(By.CSS_SELECTOR, "[auto-id=constant_popup_save_button]").click()
+        time.sleep(1)
+
+        constant = db_util.get_constant("Constant Name")
+        self.assertEqual(constant.value, "Value New")
+
+    @ui_util.screenshot_on_error
+    def test_edit_credential(self):
+        """Test editing an existing credential."""
+        # Create a credential
+        db_util.create_credential("Credential Name", "Username", "Password")
+        ui_util.refresh_ui(self.browser)
+
+        # Click credential in table
+        ui_util.click_table_row(self.browser, "constants_tab_credentials_table", 0)
+
+        self.browser.find_element(By.CSS_SELECTOR, "[auto-id=credential_popup_username_input]").send_keys(" New")
+        self.browser.find_element(By.CSS_SELECTOR, "[auto-id=credential_popup_password_input]").send_keys("Password New")
+        self.browser.find_element(By.CSS_SELECTOR, "[auto-id=credential_popup_save_button]").click()
+        time.sleep(1)
+
+        # Make sure the encryption key matches the one in the ui
+        crypto_util.set_key(ui_util.ENCRYPTION_KEY)
+
+        credential = db_util.get_credential("Credential Name")
+        self.assertEqual(credential.username, "Username New")
+        self.assertEqual(credential.password, "Password New")
+
+    @ui_util.screenshot_on_error
+    def test_delete_constant(self):
+        """Test deleting a constant."""
+        # Create a constant
+        db_util.create_constant("Constant Name", "Value")
+        ui_util.refresh_ui(self.browser)
+
+        # Click constant in table
+        ui_util.click_table_row(self.browser, "constants_tab_constants_table", 0)
+
+        self.browser.find_element(By.CSS_SELECTOR, "[auto-id=constant_popup_delete_button]").click()
+        self.browser.find_element(By.CSS_SELECTOR, "[auto-id=popup_option1_button]").click()
+        time.sleep(1)
+
+        with self.assertRaises(ValueError):
+            db_util.get_constant("Constant Name")
+
+    @ui_util.screenshot_on_error
+    def test_delete_credential(self):
+        """Test deleting a credential."""
+        # Create a credential
+        db_util.create_credential("Credential Name", "Username", "Password")
+        ui_util.refresh_ui(self.browser)
+
+        # Click credential in table
+        ui_util.click_table_row(self.browser, "constants_tab_credentials_table", 0)
+
+        self.browser.find_element(By.CSS_SELECTOR, "[auto-id=credential_popup_delete_button]").click()
+        self.browser.find_element(By.CSS_SELECTOR, "[auto-id=popup_option1_button]").click()
+        time.sleep(1)
+
+        with self.assertRaises(ValueError):
+            db_util.get_credential("Credential Name")
+
+
+if __name__ == '__main__':
+    unittest.main()

OpenOrchestrator/tests/ui_tests/test_logging_tab.py

@@ -0,0 +1,180 @@
+"""Tests relating to the logs tab in Orchestrator."""
+
+import unittest
+from datetime import datetime, timedelta
+import time
+
+from selenium.webdriver.common.by import By
+from selenium.webdriver.common.keys import Keys
+
+from OpenOrchestrator.tests import db_test_util
+from OpenOrchestrator.database import db_util
+from OpenOrchestrator.database.logs import LogLevel
+from OpenOrchestrator.tests.ui_tests import ui_util
+
+
+class TestLogsTab(unittest.TestCase):
+    """Test functionality of the logs tab ui."""
+    def setUp(self) -> None:
+        self.browser = ui_util.open_orchestrator()
+        db_test_util.establish_clean_database()
+        self.browser.find_element(By.CSS_SELECTOR, "[auto-id=logs_tab]").click()
+        ui_util.refresh_ui(self.browser)
+
+    def tearDown(self) -> None:
+        self.browser.quit()
+
+    @ui_util.screenshot_on_error
+    def test_logs_table(self):
+        """Test that logs are shown correctly in the logs table."""
+        # Create some logs
+        self._create_logs()
+
+        ui_util.refresh_ui(self.browser)
+
+        # Check result
+        table_data = ui_util.get_table_data(self.browser, "logs_tab_logs_table")
+        self.assertRegex(table_data[0][0], r"\d{2}-\d{2}-\d{4} \d{2}:\d{2}:\d{2}")
+        self.assertEqual(table_data[0][1], "Test Error")
+        self.assertEqual(table_data[0][2], LogLevel.ERROR.value)
+        self.assertEqual(table_data[0][3], "Error Message")
+
+        self.assertRegex(table_data[1][0], r"\d{2}-\d{2}-\d{4} \d{2}:\d{2}:\d{2}")
+        self.assertEqual(table_data[1][1], "Test Info")
+        self.assertEqual(table_data[1][2], LogLevel.INFO.value)
+        self.assertEqual(table_data[1][3], "Info Message")
+
+        self.assertRegex(table_data[2][0], r"\d{2}-\d{2}-\d{4} \d{2}:\d{2}:\d{2}")
+        self.assertEqual(table_data[2][1], "Test Trace")
+        self.assertEqual(table_data[2][2], LogLevel.TRACE.value)
+        self.assertEqual(table_data[2][3], "Trace Message")
+
+    @ui_util.screenshot_on_error
+    def test_date_filter(self):
+        """Test filtering on date."""
+        yesterday = datetime.today() - timedelta(days=1)
+        tomorrow = datetime.today() + timedelta(days=1)
+
+        self._create_logs()
+        ui_util.refresh_ui(self.browser)
+
+        # No filter
+        table_data = ui_util.get_table_data(self.browser, "logs_tab_logs_table")
+        self.assertEqual(len(table_data), 3)
+
+        # From yesterday
+        self._set_date_filter(from_date=yesterday, to_date=None)
+        table_data = ui_util.get_table_data(self.browser, "logs_tab_logs_table")
+        self.assertEqual(len(table_data), 3)
+
+        # From tomorrow
+        self._set_date_filter(from_date=tomorrow, to_date=None)
+        table_data = ui_util.get_table_data(self.browser, "logs_tab_logs_table")
+        self.assertEqual(len(table_data), 0)
+
+        # To yesterday
+        self._set_date_filter(from_date=None, to_date=yesterday)
+        table_data = ui_util.get_table_data(self.browser, "logs_tab_logs_table")
+        self.assertEqual(len(table_data), 0)
+
+        # To tomorrow
+        self._set_date_filter(from_date=None, to_date=tomorrow)
+        table_data = ui_util.get_table_data(self.browser, "logs_tab_logs_table")
+        self.assertEqual(len(table_data), 3)
+
+        # From yesterday To tomorrow
+        self._set_date_filter(from_date=yesterday, to_date=tomorrow)
+        table_data = ui_util.get_table_data(self.browser, "logs_tab_logs_table")
+        self.assertEqual(len(table_data), 3)
+
+        # Clear filter
+        self._set_date_filter(None, None)
+
+    @ui_util.screenshot_on_error
+    def test_process_filter(self):
+        """Test filtering on process name."""
+        self._create_logs()
+
+        self._set_process_filter(2)
+        table_data = ui_util.get_table_data(self.browser, "logs_tab_logs_table")
+        self.assertEqual(table_data[0][1], "Test Error")
+
+        self._set_process_filter(3)
+        table_data = ui_util.get_table_data(self.browser, "logs_tab_logs_table")
+        self.assertEqual(table_data[0][1], "Test Info")
+
+        self._set_process_filter(4)
+        table_data = ui_util.get_table_data(self.browser, "logs_tab_logs_table")
+        self.assertEqual(table_data[0][1], "Test Trace")
+
+        self._set_process_filter(1)
+        table_data = ui_util.get_table_data(self.browser, "logs_tab_logs_table")
+        self.assertEqual(len(table_data), 3)
+
+    @ui_util.screenshot_on_error
+    def test_level_filter(self):
+        """Test filtering on log level."""
+        self._create_logs()
+
+        self._set_level_filter(2)
+        table_data = ui_util.get_table_data(self.browser, "logs_tab_logs_table")
+        self.assertEqual(table_data[0][1], "Test Trace")
+
+        self._set_level_filter(3)
+        table_data = ui_util.get_table_data(self.browser, "logs_tab_logs_table")
+        self.assertEqual(table_data[0][1], "Test Info")
+
+        self._set_level_filter(4)
+        table_data = ui_util.get_table_data(self.browser, "logs_tab_logs_table")
+        self.assertEqual(table_data[0][1], "Test Error")
+
+        self._set_level_filter(1)
+        table_data = ui_util.get_table_data(self.browser, "logs_tab_logs_table")
+        self.assertEqual(len(table_data), 3)
+
+    def _set_date_filter(self, from_date: datetime | None, to_date: datetime | None):
+        # Clear filters
+        from_input = self.browser.find_element(By.CSS_SELECTOR, "[auto-id=logs_tab_from_input]")
+        from_input.send_keys(Keys.CONTROL, "a", Keys.DELETE)
+        to_input = self.browser.find_element(By.CSS_SELECTOR, "[auto-id=logs_tab_to_input]")
+        to_input.send_keys(Keys.CONTROL, "a", Keys.DELETE)
+
+        if from_date:
+            from_input.send_keys(from_date.strftime("%d-%m-%Y %H:%M"))
+
+        if to_date:
+            to_input.send_keys(to_date.strftime("%d-%m-%Y %H:%M"))
+
+    def _set_process_filter(self, index: int):
+        """Select a process in the process filter.
+
+        Args:
+            index: The 1-based index of the process to choose.
+        """
+        self.browser.find_element(By.CSS_SELECTOR, "[auto-id=logs_tab_process_input]").click()
+        self.browser.find_element(By.XPATH, f"//div[@role='listbox']//div[contains(@class, 'q-item')][{index}]").click()
+        time.sleep(0.5)
+
+    def _set_level_filter(self, index: int):
+        """Select a level in the level filter.
+
+        Args:
+            index: The 1-based index of the level to choose.
+        """
+        self.browser.find_element(By.CSS_SELECTOR, "[auto-id=logs_tab_level_input]").click()
+        self.browser.find_element(By.XPATH, f"//div[@role='listbox']//div[contains(@class, 'q-item')][{index}]").click()
+        time.sleep(0.5)
+
+    def _create_logs(self):
+        """Create some logs for testing."""
+        db_util.create_log("Test Trace", LogLevel.TRACE, "Trace Message")
+        time.sleep(0.1)
+        db_util.create_log("Test Info", LogLevel.INFO, "Info Message")
+        time.sleep(0.1)
+        db_util.create_log("Test Error", LogLevel.ERROR, "Error Message")
+
+        ui_util.refresh_ui(self.browser)
+
+
+if __name__ == '__main__':
+    unittest.main()

OpenOrchestrator/tests/ui_tests/test_queues_tab.py

@@ -0,0 +1,126 @@
+"""Tests relating to the queues tab in Orchestrator."""
+
+import unittest
+from datetime import datetime, timedelta
+
+from selenium.webdriver.common.by import By
+from selenium.webdriver.common.keys import Keys
+
+from OpenOrchestrator.tests import db_test_util
+from OpenOrchestrator.database import db_util
+from OpenOrchestrator.database.queues import QueueStatus
+from OpenOrchestrator.tests.ui_tests import ui_util
+
+
+class TestQueuesTab(unittest.TestCase):
+    """Test functionality of the queues tab ui."""
+    def setUp(self) -> None:
+        self.browser = ui_util.open_orchestrator()
+        db_test_util.establish_clean_database()
+        self.browser.find_element(By.CSS_SELECTOR, "[auto-id=queues_tab]").click()
+        ui_util.refresh_ui(self.browser)
+
+    def tearDown(self) -> None:
+        self.browser.quit()
+
+    @ui_util.screenshot_on_error
+    def test_queues_table(self):
+        """Test that queues are displayed correctly in the queues table."""
+        self._create_queue_elements()
+        ui_util.refresh_ui(self.browser)
+
+        table_data = ui_util.get_table_data(self.browser, "queues_tab_queue_table")
+        self.assertEqual(table_data[0], ["Queue Name 1", "1", "2", "3", "4", "5"])
+        self.assertEqual(table_data[1], ["Queue Name 2", "1", "2", "3", "4", "5"])
+
+    @ui_util.screenshot_on_error
+    def test_queue_popup(self):
+        """Test that queue elements are displayed correctly in the queue popup."""
+        self._create_queue_elements()
+        ui_util.refresh_ui(self.browser)
+
+        ui_util.click_table_row(self.browser, "queues_tab_queue_table", 0)
+
+        table_data = ui_util.get_table_data(self.browser, "queue_popup_table")
+
+        queue_elements = db_util.get_queue_elements("Queue Name 1")
+
+        self.assertEqual(len(table_data), len(queue_elements))
+        for i, queue_element in enumerate(queue_elements):
+            self.assertIn(table_data[i][0], queue_element.reference)
+            self.assertEqual(table_data[i][1], queue_element.status.value)
+            self.assertEqual(table_data[i][2], queue_element.data)
+            self.assertEqual(table_data[i][3], queue_element.message)
+            self.assertRegex(table_data[i][4], r"(\d{2}-\d{2}-\d{4} \d{2}:\d{2}:\d{2})|(N/A)")
+            self.assertRegex(table_data[i][5], r"(\d{2}-\d{2}-\d{4} \d{2}:\d{2}:\d{2})|(N/A)")
+            self.assertRegex(table_data[i][6], r"(\d{2}-\d{2}-\d{4} \d{2}:\d{2}:\d{2})|(N/A)")
+            self.assertEqual(table_data[i][7], queue_element.created_by)
+
+        self.browser.find_element(By.CSS_SELECTOR, "[auto-id=queue_popup_close_button]").click()
+
+    @ui_util.screenshot_on_error
+    def test_queue_popup_filters(self):
+        """Test setting filters in the queue popup."""
+        self._create_queue_elements()
+        ui_util.refresh_ui(self.browser)
+
+        ui_util.click_table_row(self.browser, "queues_tab_queue_table", 0)
+
+        yesterday = datetime.today() - timedelta(days=1)
+        tomorrow = datetime.today() + timedelta(days=1)
+
+        table_data = ui_util.get_table_data(self.browser, "queue_popup_table")
+        self.assertEqual(len(table_data), 15)
+
+        # From yesterday
+        self._set_date_filter(from_date=yesterday, to_date=None)
+        table_data = ui_util.get_table_data(self.browser, "queue_popup_table")
+        self.assertEqual(len(table_data), 15)
+
+        # From tomorrow
+        self._set_date_filter(from_date=tomorrow, to_date=None)
+        table_data = ui_util.get_table_data(self.browser, "queue_popup_table")
+        self.assertEqual(len(table_data), 0)
+
+        # To yesterday
+        self._set_date_filter(from_date=None, to_date=yesterday)
+        table_data = ui_util.get_table_data(self.browser, "queue_popup_table")
+        self.assertEqual(len(table_data), 0)
+
+        # From yesterday to tomorrow
+        self._set_date_filter(from_date=yesterday, to_date=tomorrow)
+        table_data = ui_util.get_table_data(self.browser, "queue_popup_table")
+        self.assertEqual(len(table_data), 15)
+
+        self.browser.find_element(By.CSS_SELECTOR, "[auto-id=queue_popup_close_button]").click()
+
+    def _create_queue_elements(self):
+        """Create some queue elements.
+        Creates 1x'New', 2x'In Progress' and so on.
+        """
+        for j in range(2):
+            for i, status in enumerate(QueueStatus):
+                for k in range(i+1):
+                    qe = db_util.create_queue_element(f"Queue Name {j+1}", reference=f"Reference {k},{i}", data=f"Data {k},{i}", created_by=f"Creator {k},{i}")
+                    db_util.set_queue_element_status(qe.id, status, message=f"Message {k},{i}")
+
+    # This code is similar to some in test_logging_tab.
+    # Since the ui might change it doesn't make sense to make a common function for this.
+    # pylint: disable=duplicate-code
+    def _set_date_filter(self, from_date: datetime | None, to_date: datetime | None):
+        """Set the date filters."""
+        # Clear filters
+        from_input = self.browser.find_element(By.CSS_SELECTOR, "[auto-id=queue_popup_from_input]")
+        from_input.send_keys(Keys.CONTROL, "a", Keys.DELETE)
+        to_input = self.browser.find_element(By.CSS_SELECTOR, "[auto-id=queue_popup_to_input]")
+        to_input.send_keys(Keys.CONTROL, "a", Keys.DELETE)
+
+        if from_date:
+            from_input.send_keys(from_date.strftime("%d-%m-%Y %H:%M"))
+
+        if to_date:
+            to_input.send_keys(to_date.strftime("%d-%m-%Y %H:%M"))
+
+
+if __name__ == '__main__':
+    unittest.main()

OpenOrchestrator/tests/ui_tests/test_schedulers_tab.py

@@ -0,0 +1,47 @@
+"""Tests relating to the schedulers tab in Orchestrator."""
+
+import unittest
+
+from selenium.webdriver.common.by import By
+
+from OpenOrchestrator.tests import db_test_util
+from OpenOrchestrator.database import db_util
+from OpenOrchestrator.tests.ui_tests import ui_util
+
+
+class TestSchedulersTab(unittest.TestCase):
+    """Test functionality of the schedulers tab ui."""
+    @classmethod
+    def setUpClass(cls) -> None:
+        cls.browser = ui_util.open_orchestrator()
+
+    @classmethod
+    def tearDownClass(cls) -> None:
+        cls.browser.quit()
+
+    def setUp(self) -> None:
+        db_test_util.establish_clean_database()
+        self.browser.find_element(By.CSS_SELECTOR, "[auto-id=schedulers_tab]").click()
+        ui_util.refresh_ui(self.browser)
+
+    @ui_util.screenshot_on_error
+    def test_schedulers_table(self):
+        """Test that schedulers are shown correctly in the schedulers table."""
+        db_util.send_ping_from_scheduler("Testmachine")
+        db_util.start_trigger_from_machine("Testmachine2", "RPA Process")
+        ui_util.refresh_ui(self.browser)
+
+        # Check that the text content is displayed correctly
+        table_data = ui_util.get_table_data(self.browser, "schedulers_tab_schedulers_table")
+        self.assertEqual(table_data[0][0], "Testmachine")
+        self.assertRegex(table_data[0][1], r"\d{2}-\d{2}-\d{4} \d{2}:\d{2}:\d{2}")
+        self.assertEqual(table_data[0][2], "None yet")
+
+        self.assertEqual(table_data[1][0], "Testmachine2")
+        self.assertRegex(table_data[1][1], r"\d{2}-\d{2}-\d{4} \d{2}:\d{2}:\d{2}")
+        self.assertEqual(table_data[1][2], "RPA Process")
+        self.assertRegex(table_data[1][3], r"\d{2}-\d{2}-\d{4} \d{2}:\d{2}:\d{2}")
+
+
+if __name__ == '__main__':
+    unittest.main()