testit-python-commons 4.2.8__py3-none-any.whl

testit_python_commons/models/test_result.py

@@ -0,0 +1,297 @@
+from typing import List
+
+from testit_python_commons.models.link import Link
+from testit_python_commons.models.step_result import StepResult
+from testit_python_commons.services.logger import adapter_logger
+from testit_python_commons.utils import HtmlEscapeUtils
+
+
+class TestResult:
+    __external_id: str = None
+    __autotest_name: str = None
+    __outcome: str = None
+    __status_type: str = None
+    __title: str = None
+    __description: str = None
+    __duration: int = None
+    __started_on: str = None
+    __completed_on: str = None
+    __namespace: str = None
+    __classname: str = None
+    __message: str = None
+    __traces: str = None
+    __step_results: List[StepResult] = []
+    __setup_results: List[StepResult] = []
+    __teardown_results: List[StepResult] = []
+    __links: List[Link] = []
+    __result_links: List[Link] = []
+    __attachments: List[str] = []
+    __labels: List[str] = []
+    __tags: List[str] = []
+    __work_item_ids: List[str] = []
+    __parameters: dict = {}
+    __properties: dict = {}
+    __automatic_creation_test_cases: bool = False
+    __external_key: str = None
+
+    @adapter_logger
+    def set_external_id(self, external_id: str):
+        # don't use escaping for externalId
+        # self.__external_id = HtmlEscapeUtils.escape_html_tags(external_id)
+        self.__external_id = external_id
+
+        return self
+
+    @adapter_logger
+    def get_external_id(self) -> str:
+        return self.__external_id
+
+    @adapter_logger
+    def set_autotest_name(self, autotest_name: str):
+        self.__autotest_name = HtmlEscapeUtils.escape_html_tags(autotest_name)
+
+        return self
+
+    @adapter_logger
+    def get_autotest_name(self) -> str:
+        return self.__autotest_name
+
+    @adapter_logger
+    def set_outcome(self, outcome: str):
+        self.__outcome = HtmlEscapeUtils.escape_html_tags(outcome)
+
+        return self
+
+    @adapter_logger
+    def get_outcome(self) -> str:
+        return self.__outcome
+
+    @adapter_logger
+    def set_status_type(self, status_type: str):
+        self.__status_type = HtmlEscapeUtils.escape_html_tags(status_type)
+
+        return self
+
+    @adapter_logger
+    def get_status_type(self) -> str:
+        return self.__status_type
+
+    @adapter_logger
+    def set_title(self, title: str):
+        self.__title = HtmlEscapeUtils.escape_html_tags(title)
+
+        return self
+
+    @adapter_logger
+    def get_title(self) -> str:
+        return self.__title
+
+    @adapter_logger
+    def set_description(self, description: str):
+        self.__description = HtmlEscapeUtils.escape_html_tags(description)
+
+        return self
+
+    @adapter_logger
+    def get_description(self) -> str:
+        return self.__description
+
+    @adapter_logger
+    def set_duration(self, duration: int):
+        self.__duration = duration
+
+        return self
+
+    @adapter_logger
+    def get_duration(self) -> int:
+        return self.__duration
+
+    @adapter_logger
+    def set_started_on(self, started_on: str):
+        self.__started_on = started_on
+
+        return self
+
+    @adapter_logger
+    def get_started_on(self) -> str:
+        return self.__started_on
+
+    @adapter_logger
+    def set_completed_on(self, completed_on: str):
+        self.__completed_on = completed_on
+
+        return self
+
+    @adapter_logger
+    def get_completed_on(self) -> str:
+        return self.__completed_on
+
+    @adapter_logger
+    def set_namespace(self, namespace: str):
+        self.__namespace = HtmlEscapeUtils.escape_html_tags(namespace)
+
+        return self
+
+    @adapter_logger
+    def get_namespace(self) -> str:
+        return self.__namespace
+
+    @adapter_logger
+    def set_classname(self, classname: str):
+        self.__classname = HtmlEscapeUtils.escape_html_tags(classname)
+
+        return self
+
+    @adapter_logger
+    def get_classname(self) -> str:
+        return self.__classname
+
+    @adapter_logger
+    def set_message(self, message: str):
+        self.__message = HtmlEscapeUtils.escape_html_tags(message)
+
+        return self
+
+    @adapter_logger
+    def get_message(self) -> str:
+        return self.__message
+
+    @adapter_logger
+    def set_traces(self, traces: str):
+        self.__traces = HtmlEscapeUtils.escape_html_tags(traces)
+
+        return self
+
+    @adapter_logger
+    def get_traces(self) -> str:
+        return self.__traces
+
+    @adapter_logger
+    def set_step_results(self, step_results: list):
+        self.__step_results = step_results
+
+        return self
+
+    @adapter_logger
+    def get_step_results(self) -> List[StepResult]:
+        return self.__step_results
+
+    @adapter_logger
+    def set_setup_results(self, setup_results: list):
+        self.__setup_results = setup_results
+
+        return self
+
+    @adapter_logger
+    def get_setup_results(self) -> List[StepResult]:
+        return self.__setup_results
+
+    @adapter_logger
+    def set_teardown_results(self, teardown_results: list):
+        self.__teardown_results = teardown_results
+
+        return self
+
+    @adapter_logger
+    def get_teardown_results(self) -> List[StepResult]:
+        return self.__teardown_results
+
+    @adapter_logger
+    def set_links(self, links: list):
+        self.__links = links
+
+        return self
+
+    @adapter_logger
+    def get_links(self) -> list:
+        return self.__links
+
+    @adapter_logger
+    def set_result_links(self, result_links: list):
+        self.__result_links = result_links
+
+        return self
+
+    @adapter_logger
+    def get_result_links(self) -> list:
+        return self.__result_links
+
+    @adapter_logger
+    def set_attachments(self, attachments: list):
+        self.__attachments = attachments
+
+        return self
+
+    @adapter_logger
+    def get_attachments(self) -> list:
+        return self.__attachments
+
+    @adapter_logger
+    def set_labels(self, labels: list):
+        self.__labels = HtmlEscapeUtils.escape_html_in_object(labels)
+
+        return self
+
+    @adapter_logger
+    def get_labels(self) -> list:
+        return self.__labels
+
+    @adapter_logger
+    def set_tags(self, tags: list):
+        self.__tags = HtmlEscapeUtils.escape_html_in_object(tags)
+
+        return self
+
+    @adapter_logger
+    def get_tags(self) -> list:
+        return self.__tags
+
+    @adapter_logger
+    def set_work_item_ids(self, work_item_ids: list):
+        self.__work_item_ids = work_item_ids
+
+        return self
+
+    @adapter_logger
+    def get_work_item_ids(self) -> list:
+        return self.__work_item_ids
+
+    @adapter_logger
+    def set_parameters(self, parameters: dict):
+        self.__parameters = HtmlEscapeUtils.escape_html_in_object(parameters)
+
+        return self
+
+    @adapter_logger
+    def get_parameters(self) -> dict:
+        return self.__parameters
+
+    @adapter_logger
+    def set_properties(self, properties: dict):
+        self.__properties = HtmlEscapeUtils.escape_html_in_object(properties)
+
+        return self
+
+    @adapter_logger
+    def get_properties(self) -> dict:
+        return self.__properties
+
+    @adapter_logger
+    def set_automatic_creation_test_cases(self, automatic_creation_test_cases: bool):
+        self.__automatic_creation_test_cases = automatic_creation_test_cases
+
+        return self
+
+    @adapter_logger
+    def get_automatic_creation_test_cases(self) -> bool:
+        return self.__automatic_creation_test_cases
+
+    @adapter_logger
+    def set_external_key(self, external_key: str):
+        self.__external_key = external_key
+
+        return self
+
+    @adapter_logger
+    def get_external_key(self) -> str:
+        return self.__external_key

testit_python_commons/models/test_result_with_all_fixture_step_results_model.py

@@ -0,0 +1,28 @@
+from testit_python_commons.models.step_result import StepResult
+from typing import List
+
+
+class TestResultWithAllFixtureStepResults:
+    def __init__(self, test_result_id: str):
+        self.__test_result_id = test_result_id
+        self.__setup_results = []
+        self.__teardown_results = []
+
+    def get_test_result_id(self) -> str:
+        return self.__test_result_id
+
+    def set_setup_results(self, setup_results: List[StepResult]):
+        self.__setup_results += setup_results
+
+        return self
+
+    def get_setup_results(self) -> List[StepResult]:
+        return self.__setup_results
+
+    def set_teardown_results(self, teardown_results: List[StepResult]):
+        self.__teardown_results = teardown_results + self.__teardown_results
+
+        return self
+
+    def get_teardown_results(self) -> List[StepResult]:
+        return self.__teardown_results

testit_python_commons/services/__init__.py

@@ -0,0 +1,41 @@
+from pluggy import HookimplMarker
+
+__all__ = [
+        "AdapterManager",
+        "TmsPluginManager",
+        "FixtureManager",
+        "StepManager",
+        "Utils",
+        "SyncStorageRunner",
+        "hookimpl",
+    ]
+
+hookimpl = HookimplMarker("testit")
+
+
+def __getattr__(name):
+    if name == "AdapterManager":
+        from testit_python_commons.services.adapter_manager import AdapterManager
+
+        return AdapterManager
+    if name == "TmsPluginManager":
+        from testit_python_commons.services.plugin_manager import TmsPluginManager
+
+        return TmsPluginManager
+    if name == "FixtureManager":
+        from testit_python_commons.services.fixture_manager import FixtureManager
+
+        return FixtureManager
+    if name == "StepManager":
+        from testit_python_commons.services.step_manager import StepManager
+
+        return StepManager
+    if name == "Utils":
+        from testit_python_commons.services.utils import Utils
+
+        return Utils
+    if name == "SyncStorageRunner":
+        from testit_python_commons.services.sync_storage import SyncStorageRunner
+
+        return SyncStorageRunner
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

testit_python_commons/services/adapter_manager.py

@@ -0,0 +1,318 @@
+import logging
+import os
+import uuid
+
+from testit_python_commons.client.api_client import ApiClientWorker
+from testit_python_commons.client.client_configuration import ClientConfiguration
+from testit_python_commons.models.adapter_mode import AdapterMode
+from testit_python_commons.models.test_result import TestResult
+from testit_python_commons.services.adapter_manager_configuration import (
+    AdapterManagerConfiguration,
+)
+from testit_python_commons.services.fixture_manager import FixtureManager
+from testit_python_commons.services.logger import adapter_logger
+from testit_python_commons.services.utils import Utils
+
+from testit_python_commons.services.sync_storage.sync_storage_runner import (
+    SyncStorageRunner,
+)
+
+SYNC_STORAGE_AVAILABLE = True
+IN_PROGRESS_LITERAL = "InProgress"
+
+
+class AdapterManager:
+    def __init__(
+        self,
+        adapter_configuration: AdapterManagerConfiguration,
+        client_configuration: ClientConfiguration,
+        fixture_manager: FixtureManager,
+    ):
+
+        self.__config = adapter_configuration
+        self.__client_config = client_configuration
+        self.__api_client = ApiClientWorker(client_configuration)
+        self.__fixture_manager = fixture_manager
+        self.__test_result_map = {}
+        self.__test_results = []
+
+        # Sync Storage integration
+        self.__sync_storage_runner = None
+        legacy_workflow_enabled = client_configuration.is_legacy_workflow() is True
+        # Initialize Sync Storage if available and enabled
+        if SYNC_STORAGE_AVAILABLE and not legacy_workflow_enabled:
+            self.__sync_storage_runner = self._initialize_sync_storage(
+                client_configuration
+            )
+
+
+    def _initialize_sync_storage(self, client_configuration: ClientConfiguration):
+        """Initialize Sync Storage runner if enabled."""
+        if client_configuration.is_legacy_workflow():
+            return None
+
+        test_run_id = self.__config.get_test_run_id()
+        if not test_run_id and self.__config.get_mode() == AdapterMode.NEW_TEST_RUN:
+            return None
+
+        if not test_run_id:
+            logging.warning('Sync Storage requires test run ID; skipping initialization')
+            return None
+
+        return self._start_sync_storage(test_run_id, client_configuration)
+
+    def _start_sync_storage(
+            self,
+            test_run_id: str,
+            client_configuration: ClientConfiguration):
+        try:
+            if not SYNC_STORAGE_AVAILABLE:
+                return None
+
+            sync_storage_runner = SyncStorageRunner(
+                test_run_id=test_run_id,
+                port=client_configuration.get_sync_storage_port(),
+                base_url=client_configuration.get_url(),
+                private_token=client_configuration.get_private_token(),
+            )
+
+            if sync_storage_runner.start():
+                logging.info("Sync Storage started successfully")
+                return sync_storage_runner
+
+            logging.warning("Failed to start Sync Storage")
+        except Exception as e:
+            logging.warning(f"Failed to initialize SyncStorage: {e}", exc_info=True)
+
+        return None
+
+    @adapter_logger
+    def set_test_run_id(self, test_run_id: str) -> None:
+
+        self.__config.set_test_run_id(test_run_id)
+
+        self.__api_client.set_test_run_id(test_run_id)
+
+        if self.__sync_storage_runner:
+            self.__sync_storage_runner.test_run_id = test_run_id
+            return
+
+        if SYNC_STORAGE_AVAILABLE and not self.__client_config.is_legacy_workflow():
+            self.__sync_storage_runner = self._start_sync_storage(
+                test_run_id, self.__client_config)
+
+    @adapter_logger
+    def get_test_run_id(self) -> str:
+        if self.__config.get_mode() != AdapterMode.NEW_TEST_RUN:
+            test_run_id = self.__config.get_test_run_id()
+
+            if test_run_id:
+                self.__update_test_run_name(test_run_id)
+
+            return test_run_id or ""
+
+        result = self.__config.get_test_run_id()
+        if result is not None:
+            return result
+
+        # create if not exists
+        test_run_name = self.__config.get_test_run_name()
+        return self.__api_client.create_test_run(test_run_name if test_run_name else "")
+
+    @adapter_logger
+    def __update_test_run_name(self, test_run_id: str) -> None:
+        test_run_name = self.__config.get_test_run_name()
+
+        if not test_run_name:
+            return
+
+        test_run = self.__api_client.get_test_run(test_run_id)
+
+        if test_run_name == test_run.name:
+            return
+
+        test_run.name = test_run_name
+
+        self.__api_client.update_test_run(test_run)
+
+    @adapter_logger
+    def get_autotests_for_launch(self):
+        if self.__config.get_mode() == AdapterMode.USE_FILTER:
+            return self.__api_client.get_external_ids_for_test_run_id()
+
+        return
+
+    @adapter_logger
+    def write_test(self, test_result: TestResult) -> None:
+        if self.__config.should_import_realtime():
+            self.__write_test_realtime(test_result)
+            return
+
+        # for realtime false
+        # if
+        logging.debug("Is already in progress: " + str(self.__is_already_in_progress()))
+        # Handle Sync Storage integration if available
+        # Check if current worker is master and no test is in progress
+        if self.__is_active_syncstorage_instance() and self.__is_master_and_no_in_progress():
+            logging.debug(f"Outcome: {test_result.get_outcome()}")
+            is_ok = self.on_master_no_already_in_progress(test_result)
+            if is_ok:
+                return
+            # else continue normal processing
+
+        self.__test_results.append(test_result)
+
+
+    @adapter_logger
+    def on_master_no_already_in_progress(self, test_result: TestResult) -> bool:
+        # Convert TestResult to TestResultCutApiModel
+
+        project_id = self.__client_config.get_project_id()
+        tr_cut_api_model = SyncStorageRunner.test_result_to_test_result_cut_api_model(
+            test_result, project_id
+        )
+        logging.debug("Set as in progress status_code, auto_test_external_id: "
+                        + tr_cut_api_model.status_code + " " + tr_cut_api_model.auto_test_external_id)
+        logging.debug("Started_on: " + str(test_result.get_started_on()))
+
+        # Send test result to Sync Storage
+        success = self.__sync_storage_runner.send_in_progress_test_result(
+            tr_cut_api_model
+        )
+
+        if not success:
+            return False
+
+        # Set the in-progress flag in the runner
+        self.__sync_storage_runner.set_is_already_in_progress(True)
+
+        try:
+            # Write test result normally (mark as IN PROGRESS in Test IT)
+            logging.debug("Write internally, change status to in progress")
+            test_result.set_outcome(IN_PROGRESS_LITERAL)
+            self._write_test_realtime_internal(test_result)
+            return True
+        except Exception as e:
+            logging.warning(
+                f"Error in Sync Storage handling, falling back to normal processing: {e}"
+            )
+            # Reset in-progress flag and continue with normal processing
+            self.__sync_storage_runner.set_is_already_in_progress(False)
+        return False
+
+    @adapter_logger
+    def __write_test_realtime(self, test_result: TestResult) -> None:
+
+        logging.debug("Is already in progress: " + str(self.__is_already_in_progress()))
+
+        # Handle Sync Storage integration if available
+        if self.__is_active_syncstorage_instance() and self.__is_master_and_no_in_progress():
+            # Check if current worker is master and no test is in progress
+            is_ok = self.on_master_no_already_in_progress(test_result)
+            if is_ok:
+                return
+            # else continue normal processing
+
+        # Normal processing (also fallback for Sync Storage errors)
+        self._write_test_realtime_internal(test_result)
+
+    def _write_test_realtime_internal(self, test_result: TestResult) -> None:
+        """Internal method for writing test results to maintain clean separation."""
+        test_result.set_automatic_creation_test_cases(
+            self.__config.should_automatic_creation_test_cases()
+        )
+
+        ext_id = test_result.get_external_id()
+        test_result_id = self.__api_client.write_test(test_result)
+        if ext_id is None or test_result_id is None:
+            logging.warning("test_result got empty external_id or test_result_id")
+            logging.warning(test_result)
+            return
+
+        self.__test_result_map[ext_id] = test_result_id
+
+    @adapter_logger
+    def write_tests(self) -> None:
+        if self.__config.should_import_realtime():
+            self.__load_setup_and_teardown_step_results()
+
+            return
+
+        self.__write_tests_after_all()
+
+    @adapter_logger
+    def __load_setup_and_teardown_step_results(self) -> None:
+        fixtures = self.__fixture_manager.get_all_items()
+        if not fixtures:
+            return
+
+        self.__api_client.update_test_results(fixtures, self.__test_result_map)
+
+    @adapter_logger
+    def __write_tests_after_all(self) -> None:
+
+        fixtures = self.__fixture_manager.get_all_items()
+
+        # Ensure this option is propagated for each buffered test result in bulk mode.
+        should_create_work_item = self.__config.should_automatic_creation_test_cases()
+        for test_result in self.__test_results:
+            test_result.set_automatic_creation_test_cases(should_create_work_item)
+
+        self.__api_client.write_tests(self.__test_results, fixtures)
+
+    @adapter_logger
+    def load_attachments(self, attach_paths):
+        return self.__api_client.load_attachments(attach_paths)
+
+    @adapter_logger
+    def create_attachment(self, body, name: str):
+        if name is None:
+            name = str(uuid.uuid4()) + "-attachment.txt"
+
+        path = os.path.join(os.path.abspath(""), name)
+
+        with open(path, "wb") as attached_file:
+            attached_file.write(Utils.convert_body_of_attachment(body))
+
+        attachment_id = self.__api_client.load_attachments((path,))
+
+        os.remove(path)
+
+        return attachment_id
+
+    @adapter_logger
+    def on_block_completed(self):
+        self.set_worker_status("completed")
+
+    @adapter_logger
+    def on_running_started(self):
+        self.set_worker_status("in_progress")
+
+    @adapter_logger
+    def set_worker_status(self, status: str):
+        logging.debug(f"Set worker_status to {status}")
+        if not self.__is_active_syncstorage_instance():
+            return
+
+        self.__sync_storage_runner.set_worker_status(status)
+
+    def is_realtime(self):
+        return self.__config.should_import_realtime()
+
+    def __is_active_syncstorage_instance(self):
+        return (self.__sync_storage_runner
+                and self.__sync_storage_runner.is_running_status()
+                )
+
+    def __is_master_and_no_in_progress(self) -> bool:
+        return (
+            self.__sync_storage_runner is not None
+            and self.__sync_storage_runner.is_master_worker()
+            and not self.__sync_storage_runner.is_already_in_progress_flag()
+        )
+
+    def __is_already_in_progress(self) -> bool:
+        return (
+            self.__sync_storage_runner is not None
+            and self.__sync_storage_runner.is_already_in_progress_flag()
+        )