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

testit_python_commons/services/adapter_manager_configuration.py

@@ -0,0 +1,42 @@
+from testit_python_commons.models.adapter_mode import AdapterMode
+from testit_python_commons.services.logger import adapter_logger
+from testit_python_commons.services.utils import Utils
+from testit_python_commons.configurations.properties_names import PropertiesNames
+
+class AdapterManagerConfiguration:
+    __test_run_id = None
+
+    def __init__(self, app_properties: dict):
+        if app_properties.get(PropertiesNames.TEST_RUN_ID):
+            self.__test_run_id = Utils.uuid_check(app_properties.get(PropertiesNames.TEST_RUN_ID))
+
+        self.__adapter_mode = app_properties.get(PropertiesNames.ADAPTER_MODE, AdapterMode.USE_FILTER)
+        self.__automatic_creation_test_cases = Utils.convert_value_str_to_bool(
+            app_properties.get(PropertiesNames.AUTOMATIC_CREATION_TEST_CASES).lower())
+
+        self.__import_realtime = Utils.convert_value_str_to_bool(app_properties.get(PropertiesNames.IMPORT_REALTIME).lower())
+        self.__test_run_name = app_properties.get(PropertiesNames.TEST_RUN_NAME)
+
+    @adapter_logger
+    def get_test_run_id(self):
+        return self.__test_run_id
+
+    @adapter_logger
+    def set_test_run_id(self, test_run_id: str):
+        self.__test_run_id = test_run_id
+
+    @adapter_logger
+    def get_test_run_name(self):
+        return self.__test_run_name
+
+    @adapter_logger
+    def get_mode(self):
+        return self.__adapter_mode
+
+    @adapter_logger
+    def should_automatic_creation_test_cases(self) -> bool:
+        return self.__automatic_creation_test_cases
+
+    @adapter_logger
+    def should_import_realtime(self) -> bool:
+        return self.__import_realtime

testit_python_commons/services/fixture_manager.py

@@ -0,0 +1,60 @@
+from testit_python_commons.services.fixture_storage import ThreadContextFixtures
+from testit_python_commons.models.step_result import StepResult
+
+
+class FixtureManager:
+    def __init__(self):
+        self._items = ThreadContextFixtures()
+        self._orphan_items = []
+
+    def _update_item(self, uuid, **kwargs):
+        item = self._items[uuid] if uuid else self._items[next(reversed(self._items))]
+        for name, value in kwargs.items():
+            attr = getattr(item, name)
+            if isinstance(attr, list):
+                attr.append(value)
+            else:
+                setattr(item, name, value)
+
+    def _last_executable(self):
+        for _uuid in reversed(self._items):
+            if isinstance(self._items[_uuid], StepResult):
+                return _uuid
+
+    def get_item(self, uuid):
+        return self._items.get(uuid)
+
+    def get_last_item(self, item_type=None):
+        for _uuid in reversed(self._items):
+            if item_type is None:
+                return self._items.get(_uuid)
+            if type(self._items[_uuid]) == item_type:
+                return self._items.get(_uuid)
+
+    def start_group(self, uuid, group):
+        self._items[uuid] = group
+
+    def stop_group(self, uuid, **kwargs):
+        self._update_item(uuid, **kwargs)
+
+    def update_group(self, uuid, **kwargs):
+        self._update_item(uuid, **kwargs)
+
+    def start_before_fixture(self, parent_uuid, uuid, fixture):
+        self._items.get(parent_uuid).befores.append(fixture)
+        self._items[uuid] = fixture
+
+    def stop_before_fixture(self, uuid, **kwargs):
+        self._update_item(uuid, **kwargs)
+        self._items.pop(uuid)
+
+    def start_after_fixture(self, parent_uuid, uuid, fixture):
+        self._items.get(parent_uuid).afters.append(fixture)
+        self._items[uuid] = fixture
+
+    def stop_after_fixture(self, uuid, **kwargs):
+        self._update_item(uuid, **kwargs)
+        self._items.pop(uuid)
+
+    def get_all_items(self):
+        return self._items.get_all()

testit_python_commons/services/fixture_storage.py

@@ -0,0 +1,40 @@
+import threading
+from collections import OrderedDict, defaultdict
+
+
+class ThreadContextFixtures:
+    _thread_context = defaultdict(OrderedDict)
+    _init_thread: threading.Thread
+
+    @property
+    def thread_context(self):
+        context = self._thread_context[threading.current_thread()]
+        if not context and threading.current_thread() is not self._init_thread:
+            uuid, last_item = next(reversed(self._thread_context[self._init_thread].items()))
+            context[uuid] = last_item
+        return context
+
+    def __init__(self, *args, **kwargs):
+        self._init_thread = threading.current_thread()
+        super().__init__(*args, **kwargs)
+
+    def __setitem__(self, key, value):
+        self.thread_context.__setitem__(key, value)
+
+    def __getitem__(self, item):
+        return self.thread_context.__getitem__(item)
+
+    def __iter__(self):
+        return self.thread_context.__iter__()
+
+    def __reversed__(self):
+        return self.thread_context.__reversed__()
+
+    def get(self, key):
+        return self.thread_context.get(key)
+
+    def pop(self, key):
+        return self.thread_context.pop(key)
+
+    def get_all(self):
+        return dict(self.thread_context.items())

testit_python_commons/services/logger.py

@@ -0,0 +1,32 @@
+from functools import wraps
+
+from testit_python_commons.services.plugin_manager import TmsPluginManager
+
+
+def adapter_logger(function):
+    @wraps(function)
+    def wrapper(*args, **kwargs):
+        from testit_python_commons.services.utils import Utils
+
+        logger = TmsPluginManager.get_logger()
+
+        parameters = Utils.get_function_parameters(function, *args, **kwargs)
+
+        message = f'Method "{function.__name__}" started'
+
+        if parameters:
+            message += f' with parameters: {parameters}'
+
+        logger.debug(message)
+
+        result = function(*args, **kwargs)
+
+        message = f'Method "{function.__name__}" finished'
+
+        if result is not None:
+            message += f' with result: {result}'
+
+        logger.debug(message)
+
+        return result
+    return wrapper

testit_python_commons/services/plugin_manager.py

@@ -0,0 +1,101 @@
+import logging
+
+from pluggy import PluginManager
+
+from testit_python_commons.app_properties import AppProperties
+from testit_python_commons.services.step_manager import StepManager
+
+
+class TmsPluginManager:
+    __plugin_manager = None
+    __adapter_manager = None
+    __fixture_manager = None
+    __step_manager = None
+    __logger = None
+    # None: non-pytest or undecided; False: pytest without --testit; True: pytest with --testit
+    __pytest_tms_report = None
+
+    @classmethod
+    def set_pytest_tms_report(cls, enabled):
+        cls.__pytest_tms_report = enabled
+
+    @classmethod
+    def get_plugin_manager(cls):
+        if cls.__plugin_manager is None:
+            cls.__plugin_manager = PluginManager("testit")
+
+        return cls.__plugin_manager
+
+    @classmethod
+    def get_adapter_manager(cls, option=None):
+        if cls.__pytest_tms_report is False:
+            return None
+
+        if cls.__adapter_manager is None:
+            from testit_python_commons.client.client_configuration import (
+                ClientConfiguration,
+            )
+            from testit_python_commons.services.adapter_manager import AdapterManager
+            from testit_python_commons.services.adapter_manager_configuration import (
+                AdapterManagerConfiguration,
+            )
+
+            app_properties = AppProperties.load_properties(option)
+
+            cls.get_logger(app_properties.get("logs") == "true")
+
+            client_configuration = ClientConfiguration(app_properties)
+            adapter_configuration = AdapterManagerConfiguration(app_properties)
+            fixture_manager = cls.get_fixture_manager()
+
+            cls.__adapter_manager = AdapterManager(
+                adapter_configuration, client_configuration, fixture_manager
+            )
+
+        return cls.__adapter_manager
+
+    @classmethod
+    def get_fixture_manager(cls):
+        if cls.__fixture_manager is None:
+            from testit_python_commons.services.fixture_manager import FixtureManager
+
+            cls.__fixture_manager = FixtureManager()
+
+        return cls.__fixture_manager
+
+    @classmethod
+    def get_step_manager(cls) -> StepManager:
+        if cls.__step_manager is None:
+            cls.__step_manager = StepManager()
+
+        return cls.__step_manager
+
+    @classmethod
+    def get_logger(cls, debug: bool = False):
+        if cls.__logger is None:
+            # Fix for live log duplication issue
+            # Create a dedicated handler for TmsLogger to avoid affecting global logging configuration
+            cls.__logger = logging.getLogger("TmsLogger")
+
+            # Only add handler if none exists to prevent duplicates
+            if not cls.__logger.handlers:
+                handler = logging.StreamHandler()
+                formatter = logging.Formatter(
+                    "\n%(levelname)s (%(asctime)s): %(message)s"
+                )
+                handler.setFormatter(formatter)
+                cls.__logger.addHandler(handler)
+
+            # Always show WARNING and above (WARNING, ERROR, CRITICAL)
+            # Only show DEBUG and INFO when debug mode is enabled
+            level = logging.DEBUG if debug else logging.WARNING
+            cls.__logger.setLevel(level)
+
+            # Prevent propagation to root logger to avoid interference with user loggers
+            cls.__logger.propagate = False
+
+        return cls.__logger
+
+    @classmethod
+    def __getattr__(cls, attribute):
+        return getattr(cls.get_plugin_manager(), attribute)

testit_python_commons/services/retry.py

@@ -0,0 +1,92 @@
+import logging
+import random
+import time
+from http.client import RemoteDisconnected
+
+import testit_api_client
+import urllib3
+
+CONNECTION_RETRIES = 3
+CONNECTION_RETRY_DELAY_SEC = 1
+API_EXCEPTION_RETRIES = 10
+NON_RETRIABLE_API_STATUS_CODES = (400, 404)
+
+_RETRIABLE_CONNECTION_TYPES = (
+    urllib3.exceptions.ProtocolError,
+    urllib3.exceptions.NewConnectionError,
+    ConnectionError,
+    ConnectionResetError,
+    ConnectionAbortedError,
+    RemoteDisconnected,
+    TimeoutError,
+)
+
+
+def is_non_retriable_api_exception(exc: BaseException) -> bool:
+    return (
+        isinstance(exc, testit_api_client.exceptions.ApiException)
+        and int(exc.status) in NON_RETRIABLE_API_STATUS_CODES
+    )
+
+
+def is_retriable_connection_error(exc: BaseException) -> bool:
+    seen = set()
+    current = exc
+    while current is not None and id(current) not in seen:
+        seen.add(id(current))
+        if isinstance(current, _RETRIABLE_CONNECTION_TYPES):
+            return True
+        current = current.__cause__ or current.__context__
+    return False
+
+
+def _execute_with_connection_retries(func, args, kwargs):
+    connection_attempts = 0
+
+    while True:
+        try:
+            return func(*args, **kwargs)
+        except BaseException as e:
+            if not is_retriable_connection_error(e):
+                raise
+
+            connection_attempts += 1
+            logging.warning(
+                'Connection error in %s (attempt %d/%d): %s',
+                func.__name__,
+                connection_attempts,
+                CONNECTION_RETRIES,
+                e,
+            )
+            if connection_attempts > CONNECTION_RETRIES:
+                raise
+
+            time.sleep(CONNECTION_RETRY_DELAY_SEC)
+
+
+def retry_on_connection_error(func):
+    def retry_wrapper(*args, **kwargs):
+        return _execute_with_connection_retries(func, args, kwargs)
+
+    return retry_wrapper
+
+
+def retry(func):
+    def retry_wrapper(*args, **kwargs):
+        api_attempts = 0
+
+        while True:
+            try:
+                return _execute_with_connection_retries(func, args, kwargs)
+            except testit_api_client.exceptions.ApiException as e:
+                if is_non_retriable_api_exception(e):
+                    raise
+
+                api_attempts += 1
+                logging.error(e)
+                if api_attempts >= API_EXCEPTION_RETRIES:
+                    raise
+
+                time.sleep(random.randrange(0, 100) / 100)
+
+    return retry_wrapper

testit_python_commons/services/step_manager.py

@@ -0,0 +1,36 @@
+from typing import List
+
+from testit_python_commons.models.step_result import StepResult
+from testit_python_commons.services.step_result_storage import StepResultStorage
+
+
+class StepManager:
+    __steps_tree: List[StepResult] = []
+
+    def __init__(self):
+        self.__storage = StepResultStorage()
+
+    def start_step(self, step: StepResult):
+        if self.__storage.get_count():
+            parent_step: StepResult = self.__storage.get_last()
+
+            step_results_from_parent_step = parent_step.get_step_results()
+            step_results_from_parent_step.append(step)
+            parent_step.set_step_results(step_results_from_parent_step)
+
+        self.__storage.add(step)
+
+    def stop_step(self):
+        if self.__storage.get_count() == 1:
+            self.__steps_tree.append(self.__storage.get_last())
+
+        self.__storage.remove_last()
+
+    def get_active_step(self) -> StepResult:
+        return self.__storage.get_last()
+
+    def get_steps_tree(self) -> List[StepResult]:
+        steps_tree = self.__steps_tree.copy()
+        self.__steps_tree.clear()
+
+        return steps_tree

testit_python_commons/services/step_result_storage.py

@@ -0,0 +1,26 @@
+import logging
+from typing import List
+
+from testit_python_commons.models.step_result import StepResult
+
+
+class StepResultStorage:
+    __storage: List[StepResult] = []
+
+    def add(self, step_result: StepResult):
+        self.__storage.append(step_result)
+
+    def get_last(self):
+        if not self.__storage:
+            return
+
+        return self.__storage[-1]
+
+    def remove_last(self):
+        try:
+            self.__storage.pop()
+        except Exception as exc:
+            logging.error(f'Cannot remove last step from storage. Storage is empty. {exc}')
+
+    def get_count(self) -> int:
+        return len(self.__storage)

testit_python_commons/services/sync_storage/__init__.py

@@ -0,0 +1,9 @@
+"""
+Sync Storage integration for Test IT Python adapters.
+"""
+
+from .sync_storage_runner import SyncStorageRunner
+
+__all__ = [
+    "SyncStorageRunner",
+]