testit-python-commons 3.7.2__tar.gz → 3.10.8.post550__tar.gz

{testit_python_commons-3.7.2 → testit_python_commons-3.10.8.post550}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: testit-python-commons
-Version: 3.7.2
+Version: 3.10.8.post550
 Summary: Python commons for Test IT
 Home-page: https://github.com/testit-tms/adapters-python/
 Author: Integration team
@@ -17,7 +17,7 @@ Classifier: Programming Language :: Python :: 3.12
 Description-Content-Type: text/markdown
 Requires-Dist: pluggy
 Requires-Dist: tomli
-Requires-Dist: testit-api-client==7.0.1
+Requires-Dist: testit-api-client==7.2.0.post550
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier

{testit_python_commons-3.7.2 → testit_python_commons-3.10.8.post550}/setup.py

@@ -1,6 +1,6 @@
 from setuptools import find_packages, setup
 
-VERSION = "3.7.2"
+VERSION = "3.10.8.post550"
 
 setup(
     name='testit-python-commons',
@@ -25,5 +25,5 @@ setup(
     py_modules=['testit', 'testit_python_commons'],
     packages=find_packages(where='src'),
     package_dir={'': 'src'},
-    install_requires=['pluggy', 'tomli', 'testit-api-client==7.0.1']
+    install_requires=['pluggy', 'tomli', 'testit-api-client==7.2.0.post550']
 )

{testit_python_commons-3.7.2 → testit_python_commons-3.10.8.post550}/src/testit_python_commons/client/api_client.py

@@ -1,36 +1,38 @@
 import logging
 import os
-import typing
 from datetime import datetime
 
 from testit_api_client import ApiClient, Configuration
 from testit_api_client.apis import AttachmentsApi, AutoTestsApi, TestRunsApi, TestResultsApi, WorkItemsApi
 from testit_api_client.models import (
+    ApiV2TestResultsSearchPostRequest,
     AutoTestApiResult,
     AutoTestPostModel,
     AutoTestPutModel,
     AttachmentPutModel,
-    AutoTestResultsForTestRunModel,
     TestResultResponse,
-    WorkItemIdModel,
+    TestResultShortResponse,
+    TestRunV2ApiResult,
+    LinkAutoTestToWorkItemRequest,
     WorkItemIdentifierModel
 )
 
 from testit_python_commons.client.client_configuration import ClientConfiguration
 from testit_python_commons.client.converter import Converter
+from testit_python_commons.client.helpers.bulk_autotest_helper import BulkAutotestHelper
 from testit_python_commons.models.test_result import TestResult
 from testit_python_commons.services.logger import adapter_logger
 from testit_python_commons.services.retry import retry
-from testit_python_commons.utils.html_escape_utils import HtmlEscapeUtils
+from typing import List
 
 
 class ApiClientWorker:
-    __max_tests_for_write = 100
+    __tests_limit = 100
 
     def __init__(self, config: ClientConfiguration):
         api_client_config = self.__get_api_client_configuration(
             url=config.get_url(),
-            verify_ssl=config.get_cert_validation() != 'false',
+            verify_ssl=config.get_cert_validation(),
             proxy=config.get_proxy())
         api_client = self.__get_api_client(api_client_config, config.get_private_token())
 
@@ -58,168 +60,149 @@ class ApiClientWorker:
             header_name='Authorization',
             header_value='PrivateToken ' + token)
 
-    @staticmethod
-    def _escape_html_in_model(model):
-        """Apply HTML escaping to all models before sending to API"""
-        return HtmlEscapeUtils.escape_html_in_object(model)
-
     @adapter_logger
-    def create_test_run(self):
+    def create_test_run(self, test_run_name: str = None) -> str:
         test_run_name = f'TestRun_{datetime.today().strftime("%Y-%m-%dT%H:%M:%S")}' if \
-            not self.__config.get_test_run_name() else self.__config.get_test_run_name()
+            not test_run_name else test_run_name
         model = Converter.test_run_to_test_run_short_model(
             self.__config.get_project_id(),
             test_run_name
         )
-        model = self._escape_html_in_model(model)
 
         response = self.__test_run_api.create_empty(create_empty_request=model)
 
         return Converter.get_id_from_create_test_run_response(response)
 
-    @adapter_logger
-    def set_test_run_id(self, test_run_id: str):
-        self.__config.set_test_run_id(test_run_id)
+    def get_test_run(self, test_run_id: str) -> TestRunV2ApiResult:
+        """Function gets test run and returns test run."""
+        logging.debug(f"Getting test run by id {test_run_id}")
 
-    @adapter_logger
-    def get_autotests_by_test_run_id(self):
-        response = self.__test_run_api.get_test_run_by_id(self.__config.get_test_run_id())
+        test_run = self.__test_run_api.get_test_run_by_id(test_run_id)
+        if test_run is not None:
+            logging.debug(f"Got testrun: {test_run}")
+            return test_run
 
-        return Converter.get_resolved_autotests_from_get_test_run_response(
-            response,
-            self.__config.get_configuration_id())
-
-    @adapter_logger
-    def write_test(self, test_result: TestResult):
-        model = Converter.project_id_and_external_id_to_auto_tests_search_post_request(
-            self.__config.get_project_id(),
-            test_result.get_external_id())
+        logging.error(f"Test run by id {test_run_id} not found!")
+        raise Exception(f"Test run by id {test_run_id} not found!")
 
-        autotests = self.__autotest_api.api_v2_auto_tests_search_post(api_v2_auto_tests_search_post_request=model)
+    def update_test_run(self, test_run: TestRunV2ApiResult) -> None:
+        """Function updates test run."""
+        model = Converter.build_update_empty_request(test_run)
+        logging.debug(f"Updating test run with model: {model}")
 
-        if autotests:
-            self.__update_test(test_result, autotests[0])
-        else:
-            self.__create_test(test_result)
+        self.__test_run_api.update_empty(update_empty_request=model)
 
-        return self.__load_test_result(test_result)
+        logging.debug(f'Updated testrun (ID: {test_run.id})')
 
     @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 = []
+    def set_test_run_id(self, test_run_id: str) -> None:
+        self.__config.set_test_run_id(test_run_id)
 
-        for test_result in test_results:
-            test_result = self.__add_fixtures_to_test_result(test_result, fixture_containers)
+    @adapter_logger
+    def get_external_ids_for_test_run_id(self) -> List[str]:
+        test_results: List[TestResultShortResponse] = self.__get_test_results()
+        external_ids: List[str] = Converter.get_external_ids_from_autotest_response_list(
+            test_results,
+            self.__config.get_configuration_id())
 
-            model = Converter.project_id_and_external_id_to_auto_tests_search_post_request(
-                self.__config.get_project_id(),
-                test_result.get_external_id())
+        if len(external_ids) > 0:
+            return external_ids
 
-            test_result_model = Converter.test_result_to_testrun_result_post_model(
-                test_result,
-                self.__config.get_configuration_id())
+        raise Exception('The autotests with the status "InProgress" ' +
+                        f'and the configuration id "{self.__config.get_configuration_id()}" were not found!')
 
-            autotests = self.__autotest_api.api_v2_auto_tests_search_post(api_v2_auto_tests_search_post_request=model)
+    def __get_test_results(self) -> List[TestResultShortResponse]:
+        all_test_results = []
+        skip = 0
+        model: ApiV2TestResultsSearchPostRequest = (
+            Converter.build_test_results_search_post_request_with_in_progress_outcome(
+                self.__config.get_test_run_id(),
+                self.__config.get_configuration_id()))
 
-            if autotests:
-                autotest_for_update = self.__prepare_to_mass_update_autotest(test_result, autotests[0])
+        while skip >= 0:
+            logging.debug(f"Getting test results with limit {self.__tests_limit}: {model}")
 
-                autotests_for_update.append(autotest_for_update)
-                results_for_autotests_being_updated.append(test_result_model)
+            test_results: List[TestResultShortResponse] = self.__test_results_api.api_v2_test_results_search_post(
+                skip=skip,
+                take=self.__tests_limit,
+                api_v2_test_results_search_post_request=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)
+            logging.debug(f"Got {len(test_results)} test results: {test_results}")
 
-                    autotests_for_update.clear()
-                    results_for_autotests_being_updated.clear()
-            else:
-                autotest_for_create = self.__prepare_to_mass_create_autotest(test_result)
+            all_test_results.extend(test_results)
+            skip += self.__tests_limit
 
-                autotests_for_create.append(autotest_for_create)
-                results_for_autotests_being_created.append(test_result_model)
+            if len(test_results) == 0:
+                skip = -1
 
-                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)
+        return all_test_results
 
-                    autotests_for_create.clear()
-                    results_for_autotests_being_created.clear()
+    @adapter_logger
+    def __get_autotests_by_external_id(self, external_id: str) -> List[AutoTestApiResult]:
+        model = Converter.project_id_and_external_id_to_auto_tests_search_post_request(
+            self.__config.get_project_id(),
+            external_id)
 
-        if len(autotests_for_update) > 0:
-            self.__update_tests(autotests_for_update)
-            self.__load_test_results(results_for_autotests_being_updated)
+        return self.__autotest_api.api_v2_auto_tests_search_post(api_v2_auto_tests_search_post_request=model)
 
-            autotests_for_update.clear()
-            results_for_autotests_being_updated.clear()
+    @adapter_logger
+    def write_test(self, test_result: TestResult) -> str:
+        model = Converter.project_id_and_external_id_to_auto_tests_search_post_request(
+            self.__config.get_project_id(),
+            test_result.get_external_id())
 
-        if len(autotests_for_create) > 0:
-            self.__create_tests(autotests_for_create)
-            self.__load_test_results(results_for_autotests_being_created)
+        autotests = self.__autotest_api.api_v2_auto_tests_search_post(api_v2_auto_tests_search_post_request=model)
 
-            autotests_for_create.clear()
-            results_for_autotests_being_created.clear()
+        if autotests:
+            self.__update_test(test_result, autotests[0])
 
-    @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())
+            autotest_id = autotests[0].id
 
-        model = Converter.test_result_to_create_autotest_request(
-            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())
+            self.__update_autotest_link_from_work_items(autotest_id, test_result.get_work_item_ids())
+        else:
+            self.__create_test(test_result)
 
-        return model
+        return self.__load_test_result(test_result)
 
     @adapter_logger
-    def __prepare_to_mass_create_autotest(self, test_result: TestResult) -> AutoTestPostModel:
-        logging.debug('Preparing to create the auto test ' + test_result.get_external_id())
+    def write_tests(self, test_results: List[TestResult], fixture_containers: dict) -> None:
+        bulk_autotest_helper = BulkAutotestHelper(self.__autotest_api, self.__test_run_api, self.__config)
 
-        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
+        for test_result in test_results:
+            test_result = self.__add_fixtures_to_test_result(test_result, fixture_containers)
 
-    @adapter_logger
-    def __prepare_to_update_autotest(
-            self,
-            test_result: TestResult,
-            autotest: AutoTestApiResult) -> AutoTestPutModel:
-        logging.debug('Preparing to update the auto test ' + test_result.get_external_id())
+            test_result_model = Converter.test_result_to_testrun_result_post_model(
+                test_result,
+                self.__config.get_configuration_id())
 
-        model = Converter.test_result_to_update_autotest_request(
-            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))
+            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
+            autotests = self.__get_autotests_by_external_id(test_result.get_external_id())
 
-    @adapter_logger
-    def __prepare_to_mass_update_autotest(
-            self,
-            test_result: TestResult,
-            autotest: AutoTestApiResult) -> AutoTestPutModel:
-        logging.debug('Preparing to update the auto test ' + test_result.get_external_id())
+            if autotests:
+                autotest_links_to_wi_for_update = {}
+                autotest_for_update = Converter.prepare_to_mass_update_autotest(
+                    test_result,
+                    autotests[0],
+                    self.__config.get_project_id())
+
+                autotest_id = autotests[0].id
+                autotest_links_to_wi_for_update[autotest_id] = test_result.get_work_item_ids()
+
+                bulk_autotest_helper.add_for_update(
+                    autotest_for_update,
+                    test_result_model,
+                    autotest_links_to_wi_for_update)
+            else:
+                autotest_for_create = Converter.prepare_to_mass_create_autotest(
+                    test_result,
+                    self.__config.get_project_id(),
+                    work_item_ids_for_link_with_auto_test)
 
-        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))
+                bulk_autotest_helper.add_for_create(autotest_for_create, test_result_model)
 
-        return model
+        bulk_autotest_helper.teardown()
 
     @staticmethod
     @adapter_logger
@@ -245,8 +228,8 @@ class ApiClientWorker:
     @adapter_logger
     def __get_work_item_uuids_for_link_with_auto_test(
             self,
-            work_item_ids: list,
-            autotest_global_id: str = None) -> list:
+            work_item_ids: List[str],
+            autotest_global_id: str = None) -> List[str]:
         linked_work_items = []
 
         if autotest_global_id:
@@ -259,8 +242,8 @@ class ApiClientWorker:
     @adapter_logger
     def __prepare_list_of_work_item_uuids(
             self,
-            linked_work_items: list,
-            work_item_ids: list) -> list:
+            linked_work_items: List[WorkItemIdentifierModel],
+            work_item_ids: List[str]) -> List[str]:
         work_item_uuids = []
 
         for linked_work_item in linked_work_items:
@@ -273,7 +256,7 @@ class ApiClientWorker:
 
                 continue
 
-            if self.__config.get_automatic_updation_links_to_test_cases() != 'true':
+            if not self.__config.get_automatic_updation_links_to_test_cases():
                 work_item_uuids.append(linked_work_item_uuid)
 
         for work_item_id in work_item_ids:
@@ -298,7 +281,7 @@ class ApiClientWorker:
             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]:
+    def __get_work_items_linked_to_autotest(self, autotest_global_id: str) -> List[WorkItemIdentifierModel]:
         return self.__autotest_api.get_work_items_linked_to_auto_test(id=autotest_global_id)
 
     @adapter_logger
@@ -313,7 +296,7 @@ class ApiClientWorker:
 
                 continue
 
-            if self.__config.get_automatic_updation_links_to_test_cases() != 'false':
+            if self.__config.get_automatic_updation_links_to_test_cases():
                 self.__unlink_test_to_work_item(autotest_global_id, linked_work_item_id)
 
         for work_item_id in work_item_ids:
@@ -323,8 +306,13 @@ class ApiClientWorker:
     def __create_test(self, test_result: TestResult) -> str:
         logging.debug(f'Autotest "{test_result.get_autotest_name()}" was not found')
 
-        model = self.__prepare_to_create_autotest(test_result)
-        model = self._escape_html_in_model(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())
+
+        model = Converter.prepare_to_create_autotest(
+            test_result,
+            self.__config.get_project_id(),
+            work_item_ids_for_link_with_auto_test)
 
         autotest_response = self.__autotest_api.create_auto_test(create_auto_test_request=model)
 
@@ -333,20 +321,18 @@ class ApiClientWorker:
         return autotest_response.id
 
     @adapter_logger
-    def __create_tests(self, autotests_for_create: typing.List[AutoTestPostModel]):
+    def __create_tests(self, autotests_for_create: List[AutoTestPostModel]) -> None:
         logging.debug(f'Creating autotests: "{autotests_for_create}')
 
-        autotests_for_create = self._escape_html_in_model(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: AutoTestApiResult):
+    def __update_test(self, test_result: TestResult, autotest: AutoTestApiResult) -> None:
         logging.debug(f'Autotest "{test_result.get_autotest_name()}" was found')
 
-        model = self.__prepare_to_update_autotest(test_result, autotest)
-        model = self._escape_html_in_model(model)
+        model = Converter.prepare_to_update_autotest(test_result, autotest, self.__config.get_project_id())
 
         try:
             self.__autotest_api.update_auto_test(update_auto_test_request=model)
@@ -356,17 +342,16 @@ class ApiClientWorker:
         logging.debug(f'Autotest "{test_result.get_autotest_name()}" was updated')
 
     @adapter_logger
-    def __update_tests(self, autotests_for_update: typing.List[AutoTestPutModel]):
+    def __update_tests(self, autotests_for_update: List[AutoTestPutModel]) -> None:
         logging.debug(f'Updating autotests: {autotests_for_update}')
 
-        autotests_for_update = self._escape_html_in_model(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):
+    def __unlink_test_to_work_item(self, autotest_global_id: str, work_item_id: str) -> None:
         self.__autotest_api.delete_auto_test_link_from_work_item(
             id=autotest_global_id,
             work_item_id=work_item_id)
@@ -375,10 +360,10 @@ class ApiClientWorker:
 
     @adapter_logger
     @retry
-    def __link_test_to_work_item(self, autotest_global_id: str, work_item_id: str):
+    def __link_test_to_work_item(self, autotest_global_id: str, work_item_id: str) -> None:
         self.__autotest_api.link_auto_test_to_work_item(
             autotest_global_id,
-            work_item_id_model=WorkItemIdModel(id=work_item_id))
+            link_auto_test_to_work_item_request=LinkAutoTestToWorkItemRequest(id=work_item_id))
 
         logging.debug(f'Autotest was linked with workItem "{work_item_id}" by global id "{autotest_global_id}')
 
@@ -387,7 +372,6 @@ class ApiClientWorker:
         model = Converter.test_result_to_testrun_result_post_model(
             test_result,
             self.__config.get_configuration_id())
-        model = self._escape_html_in_model(model)
 
         response = self.__test_run_api.set_auto_test_results_for_test_run(
             id=self.__config.get_test_run_id(),
@@ -398,21 +382,12 @@ class ApiClientWorker:
 
         return Converter.get_test_result_id_from_testrun_result_post_response(response)
 
-    @adapter_logger
-    def __load_test_results(self, test_results: typing.List[AutoTestResultsForTestRunModel]):
-        logging.debug(f'Loading test results: {test_results}')
-
-        test_results = self._escape_html_in_model(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, fixtures_containers: dict, test_result_ids: dict):
+    def update_test_results(self, fixtures_containers: dict, test_result_ids: dict) -> None:
         test_results = Converter.fixtures_containers_to_test_results_with_all_fixture_step_results(
             fixtures_containers, test_result_ids)
 
@@ -424,8 +399,6 @@ class ApiClientWorker:
                     test_result.get_setup_results())
             model.teardown_results = Converter.step_results_to_auto_test_step_result_update_request(
                     test_result.get_teardown_results())
-            
-            model = self._escape_html_in_model(model)
 
             try:
                 self.__test_results_api.api_v2_test_results_id_put(
@@ -435,7 +408,7 @@ class ApiClientWorker:
                 logging.error(f'Cannot update test result with id "{test_result.get_test_result_id()}" status: {exc}')
 
     @adapter_logger
-    def load_attachments(self, attach_paths: list or tuple):
+    def load_attachments(self, attach_paths: list or tuple) -> List[AttachmentPutModel]:
         attachments = []
 
         for path in attach_paths:

{testit_python_commons-3.7.2 → testit_python_commons-3.10.8.post550}/src/testit_python_commons/client/client_configuration.py

@@ -16,11 +16,11 @@ class ClientConfiguration:
         self.__url = Utils.url_check(app_properties.get('url'))
         self.__private_token = app_properties.get('privatetoken')
         self.__configuration_id = Utils.uuid_check(app_properties.get('configurationid'))
-        self.__test_run_name = app_properties.get('testrunname')
         self.__tms_proxy = app_properties.get('tmsproxy')
         self.__adapter_mode = app_properties.get('adaptermode')
-        self.__cert_validation = app_properties.get('certvalidation')
-        self.__automatic_updation_links_to_test_cases = app_properties.get('automaticupdationlinkstotestcases')
+        self.__cert_validation = Utils.convert_value_str_to_bool(app_properties.get('certvalidation').lower())
+        self.__automatic_updation_links_to_test_cases = Utils.convert_value_str_to_bool(
+            app_properties.get('automaticupdationlinkstotestcases').lower())
 
     @adapter_logger
     def get_url(self):
@@ -50,10 +50,6 @@ class ClientConfiguration:
     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_proxy(self):
         return self.__tms_proxy
@@ -62,8 +58,8 @@ class ClientConfiguration:
     def get_mode(self):
         return self.__adapter_mode
 
-    def get_cert_validation(self):
+    def get_cert_validation(self) -> bool:
         return self.__cert_validation
 
-    def get_automatic_updation_links_to_test_cases(self):
+    def get_automatic_updation_links_to_test_cases(self) -> bool:
         return self.__automatic_updation_links_to_test_cases