testit-python-commons 3.3.2__tar.gz → 3.4.1__tar.gz

{testit_python_commons-3.3.2 → testit_python_commons-3.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: testit-python-commons
-Version: 3.3.2
+Version: 3.4.1
 Summary: Python commons for Test IT
 Home-page: https://github.com/testit-tms/adapters-python/
 Author: Integration team
@@ -17,6 +17,15 @@ Classifier: Programming Language :: Python :: 3.12
 Description-Content-Type: text/markdown
 Requires-Dist: pluggy
 Requires-Dist: testit-api-client==5.0.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: requires-dist
+Dynamic: summary
 
 # How to enable debug logging?
 1. Add in **connection_config.ini** file from the root directory of the project:

{testit_python_commons-3.3.2 → testit_python_commons-3.4.1}/setup.py

@@ -2,7 +2,7 @@ from setuptools import find_packages, setup
 
 setup(
     name='testit-python-commons',
-    version='3.3.2',
+    version='3.4.1',
     description='Python commons for Test IT',
     long_description=open('README.md', "r").read(),
     long_description_content_type="text/markdown",

{testit_python_commons-3.3.2 → testit_python_commons-3.4.1}/src/testit_python_commons/app_properties.py

@@ -113,6 +113,10 @@ class AppProperties:
                 option.set_automatic_updation_links_to_test_cases):
             cli_properties['automaticupdationlinkstotestcases'] = option.set_automatic_updation_links_to_test_cases
 
+        if hasattr(option, 'set_import_realtime') and cls.__check_property_value(
+                option.set_import_realtime):
+            cli_properties['importrealtime'] = option.set_import_realtime
+
         return cli_properties
 
     @classmethod
@@ -165,6 +169,11 @@ class AppProperties:
             env_properties['automaticupdationlinkstotestcases'] = os.environ.get(
                 f'{cls.__env_prefix}_AUTOMATIC_UPDATION_LINKS_TO_TEST_CASES')
 
+        if f'{cls.__env_prefix}_IMPORT_REALTIME' in os.environ.keys() and cls.__check_property_value(
+                os.environ.get(f'{cls.__env_prefix}_IMPORT_REALTIME')):
+            env_properties['importrealtime'] = os.environ.get(
+                f'{cls.__env_prefix}_IMPORT_REALTIME')
+
         return env_properties
 
     @classmethod
@@ -226,6 +235,9 @@ class AppProperties:
         if not cls.__check_property_value(properties.get('automaticupdationlinkstotestcases')):
             properties['automaticupdationlinkstotestcases'] = 'false'
 
+        if not cls.__check_property_value(properties.get('importrealtime')):
+            properties['importrealtime'] = 'true'
+
     @staticmethod
     def __search_in_environ(var_name: str):
         if re.fullmatch(r'{[a-zA-Z_]\w*}', var_name) and var_name[1:-1] in os.environ:

{testit_python_commons-3.3.2 → testit_python_commons-3.4.1}/src/testit_python_commons/client/api_client.py

@@ -4,10 +4,14 @@ import typing
 from datetime import datetime
 
 from testit_api_client import ApiClient, Configuration
-from testit_api_client.api import AttachmentsApi, AutoTestsApi, TestRunsApi, TestResultsApi
+from testit_api_client.api import AttachmentsApi, AutoTestsApi, TestRunsApi, TestResultsApi, WorkItemsApi
 from testit_api_client.models import (
+    AutoTestModel,
+    AutoTestPostModel,
+    AutoTestPutModel,
     AttachmentPutModel,
-    TestResultModel,
+    AutoTestResultsForTestRunModel,
+    TestResultResponse,
     WorkItemIdModel,
     WorkItemIdentifierModel
 )
@@ -15,13 +19,13 @@ from testit_api_client.models import (
 from testit_python_commons.client.client_configuration import ClientConfiguration
 from testit_python_commons.client.converter import Converter
 from testit_python_commons.models.test_result import TestResult
-from testit_python_commons.models.test_result_with_all_fixture_step_results_model import \
-    TestResultWithAllFixtureStepResults
 from testit_python_commons.services.logger import adapter_logger
 from testit_python_commons.services.retry import retry
 
 
 class ApiClientWorker:
+    __max_tests_for_write = 100
+
     def __init__(self, config: ClientConfiguration):
         api_client_config = self.__get_api_client_configuration(
             url=config.get_url(),
@@ -33,6 +37,7 @@ class ApiClientWorker:
         self.__autotest_api = AutoTestsApi(api_client=api_client)
         self.__attachments_api = AttachmentsApi(api_client=api_client)
         self.__test_results_api = TestResultsApi(api_client=api_client)
+        self.__work_items_api = WorkItemsApi(api_client=api_client)
         self.__config = config
 
     @staticmethod
@@ -86,16 +91,175 @@ class ApiClientWorker:
         autotests = self.__autotest_api.api_v2_auto_tests_search_post(autotests_select_model=model)
 
         if autotests:
-            self.__update_test(test_result, autotests[0].is_flaky)
-
-            autotest_global_id = autotests[0].id
+            self.__update_test(test_result, autotests[0])
         else:
-            autotest_global_id = self.__create_test(test_result)
+            self.__create_test(test_result)
+
+        return self.__load_test_result(test_result)
+
+    @adapter_logger
+    def write_tests(self, test_results: typing.List[TestResult], fixture_containers: dict):
+        autotests_for_create = []
+        autotests_for_update = []
+        results_for_autotests_being_created = []
+        results_for_autotests_being_updated = []
+
+        for test_result in test_results:
+            test_result = self.__add_fixtures_to_test_result(test_result, fixture_containers)
+
+            model = Converter.project_id_and_external_id_to_auto_tests_search_post_request(
+                self.__config.get_project_id(),
+                test_result.get_external_id())
+
+            test_result_model = Converter.test_result_to_testrun_result_post_model(
+                test_result,
+                self.__config.get_configuration_id())
+
+            autotests = self.__autotest_api.api_v2_auto_tests_search_post(autotests_select_model=model)
+
+            if autotests:
+                autotest_for_update = self.__prepare_to_update_autotest(test_result, autotests[0])
+
+                autotests_for_update.append(autotest_for_update)
+                results_for_autotests_being_updated.append(test_result_model)
+
+                if len(autotests_for_update) >= self.__max_tests_for_write:
+                    self.__update_tests(autotests_for_update)
+                    self.__load_test_results(results_for_autotests_being_updated)
+
+                    autotests_for_update.clear()
+                    results_for_autotests_being_updated.clear()
+            else:
+                autotest_for_create = self.__prepare_to_create_autotest(test_result)
+
+                autotests_for_create.append(autotest_for_create)
+                results_for_autotests_being_created.append(test_result_model)
+
+                if len(autotests_for_create) >= self.__max_tests_for_write:
+                    self.__create_tests(autotests_for_create)
+                    self.__load_test_results(results_for_autotests_being_created)
+
+                    autotests_for_create.clear()
+                    results_for_autotests_being_created.clear()
+
+        if len(autotests_for_update) > 0:
+            self.__update_tests(autotests_for_update)
+            self.__load_test_results(results_for_autotests_being_updated)
+
+            autotests_for_update.clear()
+            results_for_autotests_being_updated.clear()
+
+        if len(autotests_for_create) > 0:
+            self.__create_tests(autotests_for_create)
+            self.__load_test_results(results_for_autotests_being_created)
+
+            autotests_for_create.clear()
+            results_for_autotests_being_created.clear()
+
+    @adapter_logger
+    def __prepare_to_create_autotest(self, test_result: TestResult) -> AutoTestPostModel:
+        logging.debug('Preparing to create the auto test ', test_result.get_external_id())
+
+        model = Converter.test_result_to_autotest_post_model(
+            test_result,
+            self.__config.get_project_id())
+        model.work_item_ids_for_link_with_auto_test = self.__get_work_item_uuids_for_link_with_auto_test(
+            test_result.get_work_item_ids())
+
+        return model
+
+    @adapter_logger
+    def __prepare_to_update_autotest(
+            self,
+            test_result: TestResult,
+            autotest: AutoTestModel) -> AutoTestPutModel:
+        logging.debug('Preparing to update the auto test ', test_result.get_external_id())
+
+        model = Converter.test_result_to_autotest_put_model(
+            test_result,
+            self.__config.get_project_id())
+        model.is_flaky = autotest.is_flaky
+        model.work_item_ids_for_link_with_auto_test = self.__get_work_item_uuids_for_link_with_auto_test(
+            test_result.get_work_item_ids(),
+            str(autotest.global_id))
+
+        return model
+
+    @staticmethod
+    @adapter_logger
+    def __add_fixtures_to_test_result(
+            test_result: TestResult,
+            fixtures_containers: dict) -> TestResult:
+        setup_results = []
+        teardown_results = []
+
+        for uuid, fixtures_container in fixtures_containers.items():
+            if test_result.get_external_id() in fixtures_container.external_ids:
+                if fixtures_container.befores:
+                    setup_results += fixtures_container.befores[0].steps
+
+                if fixtures_container.afters:
+                    teardown_results = fixtures_container.afters[0].steps + teardown_results
+
+        test_result.set_setup_results(setup_results)
+        test_result.set_teardown_results(teardown_results)
+
+        return test_result
+
+    @adapter_logger
+    def __get_work_item_uuids_for_link_with_auto_test(
+            self,
+            work_item_ids: list,
+            autotest_global_id: str = None) -> list:
+        linked_work_items = []
 
         if autotest_global_id:
-            self.__update_autotest_link_from_work_items(autotest_global_id, test_result.get_work_item_ids())
+            linked_work_items = self.__get_work_items_linked_to_autotest(autotest_global_id)
 
-        return self.__load_test_result(test_result)
+        work_item_uuids = self.__prepare_list_of_work_item_uuids(linked_work_items, work_item_ids)
+
+        return work_item_uuids
+
+    @adapter_logger
+    def __prepare_list_of_work_item_uuids(
+            self,
+            linked_work_items: list,
+            work_item_ids: list) -> list:
+        work_item_uuids = []
+
+        for linked_work_item in linked_work_items:
+            linked_work_item_id = str(linked_work_item.global_id)
+            linked_work_item_uuid = linked_work_item.id
+
+            if linked_work_item_id in work_item_ids:
+                work_item_ids.remove(linked_work_item_id)
+                work_item_uuids.append(linked_work_item_uuid)
+
+                continue
+
+            if self.__config.get_automatic_updation_links_to_test_cases() != 'true':
+                work_item_uuids.append(linked_work_item_uuid)
+
+        for work_item_id in work_item_ids:
+            work_item_uuid = self.__get_work_item_uuid_by_work_item_id(work_item_id)
+
+            if work_item_uuid:
+                work_item_uuids.append(work_item_uuid)
+
+        return work_item_uuids
+
+    @adapter_logger
+    def __get_work_item_uuid_by_work_item_id(self, work_item_id: str) -> str or None:
+        logging.debug('Getting workitem by id ' + work_item_id)
+
+        try:
+            work_item = self.__work_items_api.get_work_item_by_id(id=work_item_id)
+
+            logging.debug(f'Got workitem {work_item}')
+
+            return work_item.id
+        except Exception as exc:
+            logging.error(f'Getting workitem by id {work_item_id} status: {exc}')
 
     @adapter_logger
     def __get_work_items_linked_to_autotest(self, autotest_global_id: str) -> typing.List[WorkItemIdentifierModel]:
@@ -123,9 +287,7 @@ class ApiClientWorker:
     def __create_test(self, test_result: TestResult) -> str:
         logging.debug(f'Autotest "{test_result.get_autotest_name()}" was not found')
 
-        model = Converter.test_result_to_autotest_post_model(
-            test_result,
-            self.__config.get_project_id())
+        model = self.__prepare_to_create_autotest(test_result)
 
         autotest_response = self.__autotest_api.create_auto_test(auto_test_post_model=model)
 
@@ -134,18 +296,31 @@ class ApiClientWorker:
         return autotest_response.id
 
     @adapter_logger
-    def __update_test(self, test_result: TestResult, is_flaky: bool):
+    def __create_tests(self, autotests_for_create: typing.List[AutoTestPostModel]):
+        logging.debug(f'Creating autotests: "{autotests_for_create}')
+
+        self.__autotest_api.create_multiple(auto_test_post_model=autotests_for_create)
+
+        logging.debug(f'Autotests were created')
+
+    @adapter_logger
+    def __update_test(self, test_result: TestResult, autotest: AutoTestModel):
         logging.debug(f'Autotest "{test_result.get_autotest_name()}" was found')
 
-        model = Converter.test_result_to_autotest_put_model(
-            test_result,
-            self.__config.get_project_id())
-        model.is_flaky = is_flaky
+        model = self.__prepare_to_update_autotest(test_result, autotest)
 
         self.__autotest_api.update_auto_test(auto_test_put_model=model)
 
         logging.debug(f'Autotest "{test_result.get_autotest_name()}" was updated')
 
+    @adapter_logger
+    def __update_tests(self, autotests_for_update: typing.List[AutoTestPutModel]):
+        logging.debug(f'Updating autotests: {autotests_for_update}')
+
+        self.__autotest_api.update_multiple(auto_test_put_model=autotests_for_update)
+
+        logging.debug(f'Autotests were updated')
+
     @adapter_logger
     @retry
     def __unlink_test_to_work_item(self, autotest_global_id: str, work_item_id: str):
@@ -180,11 +355,22 @@ class ApiClientWorker:
         return Converter.get_test_result_id_from_testrun_result_post_response(response)
 
     @adapter_logger
-    def get_test_result_by_id(self, test_result_id: str) -> TestResultModel:
+    def __load_test_results(self, test_results: typing.List[AutoTestResultsForTestRunModel]):
+        logging.debug(f'Loading test results: {test_results}')
+
+        self.__test_run_api.set_auto_test_results_for_test_run(
+            id=self.__config.get_test_run_id(),
+            auto_test_results_for_test_run_model=test_results)
+
+    @adapter_logger
+    def get_test_result_by_id(self, test_result_id: str) -> TestResultResponse:
         return self.__test_results_api.api_v2_test_results_id_get(id=test_result_id)
 
     @adapter_logger
-    def update_test_results(self, test_results: typing.List[TestResultWithAllFixtureStepResults]):
+    def update_test_results(self, fixtures_containers: dict, test_result_ids: dict):
+        test_results = Converter.fixtures_containers_to_test_results_with_all_fixture_step_results(
+            fixtures_containers, test_result_ids)
+
         for test_result in test_results:
             model = Converter.convert_test_result_model_to_test_results_id_put_request(
                 self.get_test_result_by_id(test_result.get_test_result_id()))

{testit_python_commons-3.3.2 → testit_python_commons-3.4.1}/src/testit_python_commons/client/converter.py

@@ -17,7 +17,7 @@ from testit_api_client.models import (
     SearchAutoTestsQueryIncludesModel,
     AutotestsSelectModel,
     TestResultUpdateV2Request,
-    TestResultModel,
+    TestResultResponse,
     TestResultV2GetModel,
     AttachmentModel,
     AttachmentUpdateRequest
@@ -179,7 +179,7 @@ class Converter:
     @adapter_logger
     def convert_test_result_model_to_test_results_id_put_request(
             cls,
-            test_result: TestResultModel) -> TestResultUpdateV2Request:
+            test_result: TestResultResponse) -> TestResultUpdateV2Request:
         return TestResultUpdateV2Request(
             failure_class_ids=test_result.failure_class_ids,
             outcome=test_result.outcome,
@@ -331,6 +331,29 @@ class Converter:
 
         return autotest_model_step_results
 
+    @staticmethod
+    @adapter_logger
+    def fixtures_containers_to_test_results_with_all_fixture_step_results(
+            fixtures_containers: dict,
+            test_result_ids: dict) -> typing.List[TestResultWithAllFixtureStepResults]:
+        test_results_with_all_fixture_step_results = []
+
+        for external_id, test_result_id in test_result_ids.items():
+            test_result_with_all_fixture_step_results = TestResultWithAllFixtureStepResults(test_result_id)
+
+            for uuid, fixtures_container in fixtures_containers.items():
+                if external_id in fixtures_container.external_ids:
+                    if fixtures_container.befores:
+                        test_result_with_all_fixture_step_results.set_setup_results(fixtures_container.befores[0].steps)
+
+                    if fixtures_container.afters:
+                        test_result_with_all_fixture_step_results.set_teardown_results(
+                            fixtures_container.afters[0].steps)
+
+            test_results_with_all_fixture_step_results.append(test_result_with_all_fixture_step_results)
+
+        return test_results_with_all_fixture_step_results
+
     @classmethod
     @adapter_logger
     def step_results_to_auto_test_step_result_update_request(

testit_python_commons-3.4.1/src/testit_python_commons/models/fixture.py

@@ -0,0 +1,24 @@
+from attr import attrs, attrib
+from attr import Factory
+
+
+@attrs
+class FixtureResult:
+    title = attrib(default=None)
+    outcome = attrib(default=None)
+    description = attrib(default=None)
+    message = attrib(default=None)
+    stacktrace = attrib(default=None)
+    steps = attrib(default=None)
+    attachments = attrib(default=Factory(list))
+    parameters = attrib(default=Factory(list))
+    start = attrib(default=None)
+    stop = attrib(default=None)
+
+
+@attrs
+class FixturesContainer:
+    uuid = attrib(default=None)
+    external_ids = attrib(default=Factory(list))
+    befores = attrib(default=Factory(list))
+    afters = attrib(default=Factory(list))

{testit_python_commons-3.3.2 → testit_python_commons-3.4.1}/src/testit_python_commons/services/__init__.py

@@ -2,6 +2,7 @@ from pluggy import HookimplMarker
 
 from testit_python_commons.services.adapter_manager import AdapterManager
 from testit_python_commons.services.plugin_manager import TmsPluginManager
+from testit_python_commons.services.fixture_manager import FixtureManager
 from testit_python_commons.services.step_manager import StepManager
 from testit_python_commons.services.utils import Utils
 
@@ -10,6 +11,7 @@ hookimpl = HookimplMarker("testit")
 __all__ = [
     'AdapterManager',
     'TmsPluginManager',
+    'FixtureManager',
     'StepManager',
     'Utils',
     'hookimpl'

{testit_python_commons-3.3.2 → testit_python_commons-3.4.1}/src/testit_python_commons/services/adapter_manager.py

@@ -1,12 +1,11 @@
 import os
-import typing
 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.models.test_result_with_all_fixture_step_results_model import TestResultWithAllFixtureStepResults
+from testit_python_commons.services.fixture_manager import FixtureManager
 from testit_python_commons.services.adapter_manager_configuration import AdapterManagerConfiguration
 from testit_python_commons.services.logger import adapter_logger
 from testit_python_commons.services.utils import Utils
@@ -16,9 +15,13 @@ class AdapterManager:
     def __init__(
             self,
             adapter_configuration: AdapterManagerConfiguration,
-            client_configuration: ClientConfiguration):
+            client_configuration: ClientConfiguration,
+            fixture_manager: FixtureManager):
         self.__config = adapter_configuration
         self.__api_client = ApiClientWorker(client_configuration)
+        self.__fixture_manager = fixture_manager
+        self.__test_result_map = {}
+        self.__test_results = []
 
     @adapter_logger
     def set_test_run_id(self, test_run_id: str):
@@ -40,15 +43,39 @@ class AdapterManager:
         return
 
     @adapter_logger
-    def write_test(self, test_result: TestResult) -> str:
+    def write_test(self, test_result: TestResult):
+        if self.__config.should_import_realtime():
+            self.__write_test_realtime(test_result)
+
+            return
+
+        self.__test_results.append(test_result)
+
+    @adapter_logger
+    def __write_test_realtime(self, test_result: TestResult):
         test_result.set_automatic_creation_test_cases(
             self.__config.should_automatic_creation_test_cases())
 
-        return self.__api_client.write_test(test_result)
+        self.__test_result_map[test_result.get_external_id()] = self.__api_client.write_test(test_result)
 
     @adapter_logger
-    def load_setup_and_teardown_step_results(self, test_results: typing.List[TestResultWithAllFixtureStepResults]):
-        self.__api_client.update_test_results(test_results)
+    def write_tests(self):
+        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):
+        self.__api_client.update_test_results(self.__fixture_manager.get_all_items(), self.__test_result_map)
+
+    @adapter_logger
+    def __write_tests_after_all(self):
+        fixtures = self.__fixture_manager.get_all_items()
+
+        self.__api_client.write_tests(self.__test_results, fixtures)
 
     @adapter_logger
     def load_attachments(self, attach_paths: list or tuple):

{testit_python_commons-3.3.2 → testit_python_commons-3.4.1}/src/testit_python_commons/services/adapter_manager_configuration.py

@@ -11,13 +11,9 @@ class AdapterManagerConfiguration:
             self.__test_run_id = Utils.uuid_check(app_properties.get('testrunid'))
 
         self.__adapter_mode = app_properties.get('adaptermode', AdapterMode.USE_FILTER)
-
-        __automatic_creation_test_cases = app_properties.get('automaticcreationtestcases')
-
-        if __automatic_creation_test_cases and __automatic_creation_test_cases == 'true':
-            self.__automatic_creation_test_cases = True
-        else:
-            self.__automatic_creation_test_cases = False
+        self.__automatic_creation_test_cases = Utils.convert_value_str_to_bool(
+            app_properties.get('automaticcreationtestcases'))
+        self.__import_realtime = Utils.convert_value_str_to_bool(app_properties.get('importrealtime'))
 
     @adapter_logger
     def get_test_run_id(self):
@@ -32,5 +28,9 @@ class AdapterManagerConfiguration:
         return self.__adapter_mode
 
     @adapter_logger
-    def should_automatic_creation_test_cases(self):
+    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-3.4.1/src/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-3.4.1/src/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-3.3.2 → testit_python_commons-3.4.1}/src/testit_python_commons/services/plugin_manager.py

@@ -9,6 +9,7 @@ from testit_python_commons.app_properties import AppProperties
 class TmsPluginManager:
     __plugin_manager = None
     __adapter_manager = None
+    __fixture_manager = None
     __step_manager = None
     __logger = None
 
@@ -32,11 +33,21 @@ class TmsPluginManager:
 
             client_configuration = ClientConfiguration(app_properties)
             adapter_configuration = AdapterManagerConfiguration(app_properties)
+            fixture_manager = cls.get_fixture_manager()
 
-            cls.__adapter_manager = AdapterManager(adapter_configuration, client_configuration)
+            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:

{testit_python_commons-3.3.2 → testit_python_commons-3.4.1}/src/testit_python_commons/services/utils.py

@@ -115,3 +115,11 @@ class Utils:
             return body
 
         return str(body).encode('utf-8')
+
+    @staticmethod
+    @adapter_logger
+    def convert_value_str_to_bool(value: str) -> bool:
+        if value:
+            return value == 'true'
+
+        return False

{testit_python_commons-3.3.2 → testit_python_commons-3.4.1}/src/testit_python_commons.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: testit-python-commons
-Version: 3.3.2
+Version: 3.4.1
 Summary: Python commons for Test IT
 Home-page: https://github.com/testit-tms/adapters-python/
 Author: Integration team
@@ -17,6 +17,15 @@ Classifier: Programming Language :: Python :: 3.12
 Description-Content-Type: text/markdown
 Requires-Dist: pluggy
 Requires-Dist: testit-api-client==5.0.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: requires-dist
+Dynamic: summary
 
 # How to enable debug logging?
 1. Add in **connection_config.ini** file from the root directory of the project:

{testit_python_commons-3.3.2 → testit_python_commons-3.4.1}/src/testit_python_commons.egg-info/SOURCES.txt

@@ -17,6 +17,7 @@ src/testit_python_commons/client/client_configuration.py
 src/testit_python_commons/client/converter.py
 src/testit_python_commons/models/__init__.py
 src/testit_python_commons/models/adapter_mode.py
+src/testit_python_commons/models/fixture.py
 src/testit_python_commons/models/link.py
 src/testit_python_commons/models/link_type.py
 src/testit_python_commons/models/outcome_type.py
@@ -26,6 +27,8 @@ src/testit_python_commons/models/test_result_with_all_fixture_step_results_model
 src/testit_python_commons/services/__init__.py
 src/testit_python_commons/services/adapter_manager.py
 src/testit_python_commons/services/adapter_manager_configuration.py
+src/testit_python_commons/services/fixture_manager.py
+src/testit_python_commons/services/fixture_storage.py
 src/testit_python_commons/services/logger.py
 src/testit_python_commons/services/plugin_manager.py
 src/testit_python_commons/services/retry.py