testit-cli 2.10.3__tar.gz → 2.10.3.post580__tar.gz

{testit_cli-2.10.3/src/testit_cli.egg-info → testit_cli-2.10.3.post580}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: testit-cli
-Version: 2.10.3
+Version: 2.10.3.post580
 Summary: This tool is the command line wrapper of Test IT allowing you to upload the test results in real time to Test IT
 Home-page: https://pypi.org/project/testit-cli/
 Author: Integration team
@@ -16,11 +16,10 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: testit-api-client==7.6.1.post580
 Requires-Dist: validators
 Requires-Dist: tqdm
 Requires-Dist: click~=8.0.4
-Requires-Dist: urllib3>=2.6.0
-Requires-Dist: python-dateutil
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier

{testit_cli-2.10.3 → testit_cli-2.10.3.post580}/setup.py

@@ -1,15 +1,6 @@
 from setuptools import find_packages, setup
 
-VERSION = "2.10.3"
-
-ADAPTERS_ROOT = "src/testit_cli/adapters_api"
-ADAPTERS_PACKAGES = ["adapters_api"] + [
-    f"adapters_api.{pkg}" for pkg in find_packages(where=ADAPTERS_ROOT)
-]
-CLI_PACKAGES = [
-    pkg for pkg in find_packages(where="src")
-    if not pkg.startswith("testit_cli.adapters_api")
-]
+VERSION = "2.10.3.post580"
 
 setup(
     name='testit-cli',
@@ -33,12 +24,9 @@ setup(
         'Programming Language :: Python :: 3.12',
     ],
     py_modules=['testit_cli'],
-    packages=CLI_PACKAGES + ADAPTERS_PACKAGES,
-    package_dir={
-        '': 'src',
-        'adapters_api': ADAPTERS_ROOT,
-    },
-    install_requires=['validators', 'tqdm', 'click~=8.0.4', 'urllib3>=2.6.0', 'python-dateutil'],
+    packages=find_packages(where='src'),
+    package_dir={'': 'src'},
+    install_requires=['testit-api-client==7.6.1.post580', 'validators', 'tqdm', 'click~=8.0.4'],
     entry_points={
         'console_scripts': [
             'testit = testit_cli.__main__:console_main'

{testit_cli-2.10.3 → testit_cli-2.10.3.post580}/src/testit_cli/apiclient.py

@@ -3,65 +3,57 @@ import logging
 import os
 import typing
 
-from adapters_api import ApiClient as AdaptersHttpClient
-from adapters_api import Configuration as AdaptersConfiguration
-from adapters_api.apis import (
-    AttachmentsApi,
-    AutoTestsApi,
-    ProjectsApi,
-    TestResultsApi,
-)
-from adapters_api.apis import TestRunsApi as AdaptersTestRunsApi
-from adapters_api.apis import (
-    WorkflowsApi,
-)
-from adapters_api.models import (
-    AdaptersAutoTestsPostRequest,
-    AdaptersAutoTestsPutRequest,
-    AdaptersAutoTestsSearchPostRequest,
-    AdaptersProjectsPostRequest,
-    AdaptersTestResultsSearchPostRequest,
-    AdaptersTestRunsIdRerunsPostRequest,
-    AdaptersTestRunsPostRequest,
-    AdaptersTestRunsPutRequest,
+from testit_api_client import ApiClient as TmsClient
+from testit_api_client import Configuration
+from testit_api_client.apis import AttachmentsApi, AutoTestsApi, TestRunsApi, TestResultsApi, ProjectsApi, WorkflowsApi
+from testit_api_client.models import (
+    ApiV2AutoTestsSearchPostRequest,
+    ApiV2TestResultsSearchPostRequest,
+    ApiV2TestRunsIdRerunsPostRequest,
     AttachmentModel,
     AttachmentPutModel,
-    AutoTestApiResult,
+    AutoTestModel,
     AutoTestResultsForTestRunModel,
-    DetailedProjectApiResult,
+    CreateAutoTestRequest,
     ManualRerunApiResult,
     ManualRerunSelectTestResultsApiModelExtractionModel,
     ManualRerunSelectTestResultsApiModelFilter,
-    ManualRerunTestResultApiModelTestResultIds,
+    TestRunV2ApiResult,
+    UpdateAutoTestRequest,
+    UpdateEmptyRequest,
     TestResultShortResponse,
-    TestRunApiResult,
+    CreateEmptyRequest,
+    AutoTestApiResult,
+    DetailedProjectApiResult,
     WorkflowApiResult,
+    CreateProjectRequest,
 )
+
 from .converter import Converter
-from .html_escape_utils import HtmlEscapeUtils
 from .http_retry import with_http_retries
 from .models.testrun import TestRun
+from .html_escape_utils import HtmlEscapeUtils
 
 
 class ApiClient:
-    """Class representing an api client (adapters API only)."""
+    """Class representing an api client"""
 
     def __init__(self, url: str, token: str, disable_cert_validation: bool):
-        auth_header = "PrivateToken " + token
+        client_config = Configuration(host=url)
+        client_config.verify_ssl = not disable_cert_validation
 
-        adapters_config = AdaptersConfiguration(host=url)
-        adapters_config.verify_ssl = not disable_cert_validation
-        adapters_client = AdaptersHttpClient(
-            configuration=adapters_config,
+        client = TmsClient(
+            configuration=client_config,
             header_name="Authorization",
-            header_value=auth_header,
+            header_value="PrivateToken " + token,
         )
-        self.__test_run_api = AdaptersTestRunsApi(api_client=adapters_client)
-        self.__autotest_api = AutoTestsApi(api_client=adapters_client)
-        self.__attachments_api = AttachmentsApi(api_client=adapters_client)
-        self.__test_results_api = TestResultsApi(api_client=adapters_client)
-        self.__projects_api = ProjectsApi(api_client=adapters_client)
-        self.__workflows_api = WorkflowsApi(api_client=adapters_client)
+
+        self.__test_run_api = TestRunsApi(api_client=client)
+        self.__autotest_api = AutoTestsApi(api_client=client)
+        self.__attachments_api = AttachmentsApi(api_client=client)
+        self.__test_results_api = TestResultsApi(api_client=client)
+        self.__projects_api = ProjectsApi(api_client=client)
+        self.__workflows_api = WorkflowsApi(api_client=client)
 
     def create_test_run(
         self,
@@ -76,14 +68,12 @@ class ApiClient:
             create_kwargs["tags"] = tags
         if links:
             create_kwargs["links"] = links
-        model = AdaptersTestRunsPostRequest(**create_kwargs)
+        model = CreateEmptyRequest(**create_kwargs)
         model = HtmlEscapeUtils.escape_html_in_object(model)
         logging.debug(f"Creating test run with model: {model}")
 
-        test_run: TestRunApiResult = with_http_retries(
-            lambda: self.__test_run_api.adapters_test_runs_post(
-                adapters_test_runs_post_request=model
-            ),
+        test_run: TestRunV2ApiResult = with_http_retries(
+            lambda: self.__test_run_api.create_empty(create_empty_request=model),
             label="Create test run",
         )
 
@@ -97,7 +87,7 @@ class ApiClient:
             )
         logging.debug(f"Test run created: {test_run}")
 
-        return Converter.test_run_api_result_to_test_run(test_run)
+        return Converter.test_run_v2_get_model_to_test_run(test_run)
 
     def rerun_test_run(self, test_run_id: str,
                        configuration_ids: list[str] = None,
@@ -112,14 +102,10 @@ class ApiClient:
                        test_result_ids: list[str] = None,
                        webhook_ids: list[str] = None) -> None:
         """Function reruns test run and returns manual rerun result."""
-        if failure_categories:
-            logging.warning(
-                "failure_categories is not supported by adapters rerun filter and will be ignored"
-            )
-
         filter_model = ManualRerunSelectTestResultsApiModelFilter(
             configuration_ids=configuration_ids,
             status_codes=status_codes,
+            failure_categories=failure_categories,
             namespace=namespace,
             class_name=class_name,
             auto_test_global_ids=auto_test_global_ids,
@@ -127,16 +113,16 @@ class ApiClient:
             exclude_auto_test_tags=exclude_auto_test_tags,
             name=auto_test_name
         ) if any(param is not None for param in [
-            configuration_ids, status_codes,
+            configuration_ids, status_codes, failure_categories,
             namespace, class_name, auto_test_global_ids, auto_test_tags,
             exclude_auto_test_tags, auto_test_name
         ]) else None
 
         extraction_model = ManualRerunSelectTestResultsApiModelExtractionModel(
-            test_result_ids=ManualRerunTestResultApiModelTestResultIds(include=test_result_ids)
+            test_result_ids=test_result_ids
         ) if test_result_ids is not None else None
 
-        model = AdaptersTestRunsIdRerunsPostRequest(
+        model = ApiV2TestRunsIdRerunsPostRequest(
             filter=filter_model,
             extraction_model=extraction_model,
             webhook_ids=webhook_ids
@@ -144,9 +130,9 @@ class ApiClient:
 
         logging.debug(f"Rerunning test run {test_run_id} with model: {model}")
 
-        result: ManualRerunApiResult = self.__test_run_api.adapters_test_runs_id_reruns_post(
+        result: ManualRerunApiResult = self.__test_run_api.api_v2_test_runs_id_reruns_post(
             id=test_run_id,
-            adapters_test_runs_id_reruns_post_request=model
+            api_v2_test_runs_id_reruns_post_request=model
         )
 
         logging.info(f'Reran testrun (ID: {test_run_id})\nTest results count: {result.test_results_count}')
@@ -154,11 +140,12 @@ class ApiClient:
 
     def update_test_run(self, test_run: TestRun) -> None:
         """Function updates test run."""
-        model: AdaptersTestRunsPutRequest = Converter.test_run_to_update_request(test_run)
+        model: UpdateEmptyRequest = Converter.test_run_to_update_empty_request(test_run)
         model = HtmlEscapeUtils.escape_html_in_object(model)
         logging.debug(f"Updating test run with model: {model}")
 
-        self.__test_run_api.adapters_test_runs_put(adapters_test_runs_put_request=model)
+        # UpdateEmptyRequest
+        self.__test_run_api.update_empty(update_empty_request=model)
 
         logging.info(f'Updated testrun (ID: {test_run.id})')
 
@@ -168,7 +155,7 @@ class ApiClient:
 
         test_run = self.get_test_run(test_run_id)
         if test_run is not None and test_run.state != "Completed":
-            self.__test_run_api.adapters_test_runs_id_complete_post(test_run_id)
+            self.__test_run_api.complete_test_run(test_run_id)
 
         logging.info(f"Completed testrun (ID: {test_run_id})")
 
@@ -176,48 +163,47 @@ class ApiClient:
         """Function gets test run and returns test run."""
         logging.debug(f"Getting test run {test_run_id}")
 
-        test_run: TestRunApiResult = self.__test_run_api.adapters_test_runs_id_get(test_run_id)
+        test_run: TestRunV2ApiResult = self.__test_run_api.get_test_run_by_id(test_run_id)
         if test_run is not None:
             logging.debug(f"Got testrun (ID: {test_run_id})")
-            return Converter.test_run_api_result_to_test_run(test_run)
+            return Converter.test_run_v2_get_model_to_test_run(test_run)
 
         logging.error(f"Test run {test_run_id} not found!")
         raise Exception(f"Test run {test_run_id} not found!")
 
-    def get_autotests(self, model: AdaptersAutoTestsSearchPostRequest) \
+    def get_autotests(self, model: ApiV2AutoTestsSearchPostRequest) \
             -> list[AutoTestApiResult]:
         """Function returns list of AutoTestApiResult."""
         logging.debug(f"Getting autotests: {model}")
 
-        autotests: list[AutoTestApiResult] = self.__autotest_api.adapters_auto_tests_search_post(
-            adapters_auto_tests_search_post_request=model)
+        autotests: list[AutoTestApiResult] = (self.__autotest_api.api_v2_auto_tests_search_post
+                                              (api_v2_auto_tests_search_post_request=model))
 
         logging.debug(f"Got autotests: {autotests}")
 
         return autotests
 
-    def create_autotest(self, model: AdaptersAutoTestsPostRequest) -> str:
+    def create_autotest(self, model: CreateAutoTestRequest) -> str:
         """Function creates autotest and returns autotest id."""
         model = HtmlEscapeUtils.escape_html_in_object(model)
 
         logging.debug(f"Creating autotest {model}")
 
-        response: AutoTestApiResult = self.__autotest_api.adapters_auto_tests_post(
-            adapters_auto_tests_post_request=model)
+        response: AutoTestModel = self.__autotest_api.create_auto_test(create_auto_test_request=model)
 
         logging.debug(f"Created autotest {response}")
 
         return str(response.id)
 
-    def update_autotest(self, model: AdaptersAutoTestsPutRequest) -> None:
+    def update_autotest(self, model: UpdateAutoTestRequest) -> None:
         """Function updates autotest"""
         try:
-            escaped_model: AdaptersAutoTestsPutRequest = HtmlEscapeUtils.escape_html_in_object(model)
+            escaped_model: UpdateAutoTestRequest = HtmlEscapeUtils.escape_html_in_object(model)
 
             logging.debug(f"Updating autotest {escaped_model}")
 
-            self.__autotest_api.adapters_auto_tests_put(
-                adapters_auto_tests_put_request=escaped_model)
+            # UpdateAutoTestRequest
+            self.__autotest_api.update_auto_test(update_auto_test_request=escaped_model)
 
             logging.debug(f'Updated "{model.name}" successfully!')
         except Exception as exc:
@@ -232,7 +218,7 @@ class ApiClient:
 
             logging.debug(f"Adding autotest results to testrun {testrun_id}: {escaped_model}")
 
-            self.__test_run_api.adapters_test_runs_id_test_results_post(
+            self.__test_run_api.set_auto_test_results_for_test_run(
                 id=testrun_id, auto_test_results_for_test_run_model=[escaped_model]
             )
             logging.debug(
@@ -249,7 +235,8 @@ class ApiClient:
             if os.path.isfile(attachment):
                 with open(attachment, "rb+") as file:
                     try:
-                        attachment_response: AttachmentModel = self.__attachments_api.adapters_attachments_post(
+                        attachment_response: AttachmentModel = self.__attachments_api.api_v2_attachments_post(
+                            # file_type
                             file=file)
 
                         attachment_ids.append(AttachmentPutModel(id=attachment_response.id))
@@ -264,13 +251,13 @@ class ApiClient:
 
     def get_test_results(
             self,
-            model: AdaptersTestResultsSearchPostRequest
+            model: ApiV2TestResultsSearchPostRequest
     ) -> list[TestResultShortResponse]:
         """Function returns list of TestResultShortGetModel."""
         logging.debug(f"Getting test results: {model}")
 
-        test_results: list[TestResultShortResponse] = self.__test_results_api.adapters_test_results_search_post(
-            adapters_test_results_search_post_request=model)
+        test_results: list[TestResultShortResponse] = self.__test_results_api.api_v2_test_results_search_post(
+            api_v2_test_results_search_post_request=model)
 
         logging.debug(f"Got test results: {test_results}")
 
@@ -278,11 +265,11 @@ class ApiClient:
 
     def __get_project(self, project_id: str) -> DetailedProjectApiResult:
         """Function returns DetailedProjectApiResult."""
-        return self.__projects_api.adapters_projects_id_get(id=project_id)
+        return self.__projects_api.get_project_by_id(id=project_id)
 
     def __get_workflow_by_id(self, workflow_id: str) -> WorkflowApiResult:
         """Function returns WorkflowApiResult."""
-        return self.__workflows_api.adapters_workflows_id_get(id=workflow_id)
+        return self.__workflows_api.api_v2_workflows_id_get(id=workflow_id)
 
     def get_status_codes(self, project_id: str) -> typing.List[str]:
         """Function returns list of statuses from project."""
@@ -293,12 +280,11 @@ class ApiClient:
 
     def create_project(self, name: str, description: str = None, is_favorite: bool = None, workflow_id: str = None) -> str:
         """Function creates project and returns project id."""
-        model = AdaptersProjectsPostRequest(
-            name=name, description=description, is_favorite=is_favorite, workflow_id=workflow_id)
+        model = CreateProjectRequest(name=name, description=description, is_favorite=is_favorite, workflow_id=workflow_id)
         model = HtmlEscapeUtils.escape_html_in_object(model)
         logging.debug(f"Creating project with model: {model}")
 
-        project = self.__projects_api.adapters_projects_post(adapters_projects_post_request=model)
+        project = self.__projects_api.create_project(create_project_request=model)
 
         logging.info(f'Created new project (ID: {project.id})')
         logging.debug(f"Project created: {project}")

{testit_cli-2.10.3 → testit_cli-2.10.3.post580}/src/testit_cli/autotests_filter.py

@@ -1,8 +1,9 @@
 import hashlib
 
-from adapters_api.model.adapters_auto_tests_search_post_request import AdaptersAutoTestsSearchPostRequest
-from adapters_api.model.adapters_test_results_search_post_request import AdaptersTestResultsSearchPostRequest
-from adapters_api.model.auto_test_api_result import AutoTestApiResult
+from testit_api_client.model.api_v2_auto_tests_search_post_request import ApiV2AutoTestsSearchPostRequest
+from testit_api_client.model.api_v2_test_results_search_post_request import ApiV2TestResultsSearchPostRequest
+from testit_api_client.model.auto_test_api_result import AutoTestApiResult
+
 from .apiclient import ApiClient
 from .converter import Converter
 from .filter_factory import FilterFactory
@@ -16,7 +17,7 @@ class AutotestsFilter:
 
     def create_filter(self):
         """Function returns str of filter by autotests for test Framework run command."""
-        test_results_search_post_request: AdaptersTestResultsSearchPostRequest = (
+        test_results_search_post_request: ApiV2TestResultsSearchPostRequest = (
             Converter.testrun_id_and_configuration_id_and_in_progress_outcome_to_test_results_search_post_request(
                 self.__config.testrun_id,
                 self.__config.configuration_id))
@@ -28,9 +29,9 @@ class AutotestsFilter:
 
             raise Exception(exception)
 
-        external_ids: list[str] = Converter.test_result_short_models_to_autotest_external_ids(test_results)
-        autotests_search_post_request: AdaptersAutoTestsSearchPostRequest = (
-            Converter.external_ids_to_autotests_search_post_request(external_ids))
+        autotest_ids: list[int] = Converter.test_result_short_get_models_to_autotest_ids(test_results)
+        autotests_search_post_request: ApiV2AutoTestsSearchPostRequest = (
+            Converter.autotest_ids_to_autotests_search_post_request(autotest_ids))
         autotests: list[AutoTestApiResult] = self.__api_client.get_autotests(autotests_search_post_request)
         external_keys: list[str] = Converter.autotest_models_to_external_keys(autotests)
 

{testit_cli-2.10.3 → testit_cli-2.10.3.post580}/src/testit_cli/click_commands.py

@@ -1,11 +1,11 @@
-from itertools import chain
-
 import click
 
+from itertools import chain
+
 from .models.config import Config
 from .service_factory import ServiceFactory
 from .testrun_metadata import parse_testrun_links, parse_testrun_tags
-from .validation import validate_url, validate_uuid
+from .validation import validate_uuid, validate_url
 
 
 @click.group()
@@ -282,7 +282,7 @@ def rerun_test_run(url, token, testrun_id, configuration_id, status_code, failur
 
 
 PYTHON_FRAMEWORKS = ['pytest', 'robotframework', 'behave', 'nose']
-JAVA_FRAMEWORKS = ['gradle-testng', 'gradle-junit5', 'gradle-junit4', 'gradle-cucumber', 'maven-testng', 'maven-junit5', 'maven-junit4', 'maven-cucumber']
+JAVA_FRAMEWORKS = ['gradle-testng', 'gradle-junit6', 'gradle-junit5', 'gradle-junit4', 'gradle-cucumber', 'maven-testng', 'maven-junit6', 'maven-junit5', 'maven-junit4', 'maven-cucumber']
 KOTLIN_FRAMEWORKS = ['kotest']
 JAVASCRIPT_FRAMEWORKS = ['cucumberjs', 'codeceptjs', 'jest', 'mocha', 'playwright', 'testcafe', 'cypress']
 DOTNET_FRAMEWORKS = ['mstest', 'nunit', 'xunit', 'specflow']

{testit_cli-2.10.3 → testit_cli-2.10.3.post580}/src/testit_cli/converter.py

@@ -1,23 +1,26 @@
 import typing
 
-from adapters_api.model.adapters_auto_tests_post_request import AdaptersAutoTestsPostRequest
-from adapters_api.model.adapters_auto_tests_put_request import AdaptersAutoTestsPutRequest
-from adapters_api.model.adapters_auto_tests_search_post_request import AdaptersAutoTestsSearchPostRequest
-from adapters_api.model.adapters_test_results_search_post_request import AdaptersTestResultsSearchPostRequest
-from adapters_api.model.adapters_test_runs_put_request import AdaptersTestRunsPutRequest
-from adapters_api.model.assign_attachment_api_model import AssignAttachmentApiModel
-from adapters_api.model.attachment_api_result import AttachmentApiResult
-from adapters_api.model.attachment_put_model import AttachmentPutModel
-from adapters_api.model.auto_test_api_result import AutoTestApiResult
-from adapters_api.model.auto_test_results_for_test_run_model import AutoTestResultsForTestRunModel
-from adapters_api.model.auto_test_search_api_model_filter import AutoTestSearchApiModelFilter
-from adapters_api.model.auto_test_search_api_model_includes import AutoTestSearchApiModelIncludes
-from adapters_api.model.link_api_result import LinkApiResult
-from adapters_api.model.test_result_short_response import TestResultShortResponse
-from adapters_api.model.test_run_api_result import TestRunApiResult
-from adapters_api.model.test_status_api_type import TestStatusApiType
-from adapters_api.model.test_status_type import TestStatusType
-from adapters_api.model.update_link_api_model import UpdateLinkApiModel
+from testit_api_client.model.api_v2_auto_tests_search_post_request import ApiV2AutoTestsSearchPostRequest
+from testit_api_client.model.api_v2_test_results_search_post_request import ApiV2TestResultsSearchPostRequest
+from testit_api_client.model.attachment_api_result import AttachmentApiResult
+from testit_api_client.model.auto_test_api_result import AutoTestApiResult
+from testit_api_client.model.auto_test_search_api_model_filter import AutoTestSearchApiModelFilter
+from testit_api_client.model.auto_test_search_api_model_includes import AutoTestSearchApiModelIncludes
+from testit_api_client.model.create_auto_test_request import CreateAutoTestRequest
+from testit_api_client.model.link_api_result import LinkApiResult
+from testit_api_client.model.test_run_v2_api_result import TestRunV2ApiResult
+from testit_api_client.model.update_auto_test_request import UpdateAutoTestRequest
+from testit_api_client.model.update_empty_request import UpdateEmptyRequest
+from testit_api_client.models import (
+    AutoTestResultsForTestRunModel,
+    AttachmentPutModel,
+    LinkPutModel,
+    TestStatusType,
+    TestStatusApiType,
+    TestResultShortResponse,
+)
+from testit_api_client.model.assign_attachment_api_model import AssignAttachmentApiModel
+
 from .models.testcase import TestCase
 from .models.testrun import TestRun
 
@@ -25,7 +28,7 @@ from .models.testrun import TestRun
 class Converter:
     @staticmethod
     def project_id_and_external_id_to_autotests_search_post_request(
-            project_id: str, external_id: str) -> AdaptersAutoTestsSearchPostRequest:
+            project_id: str, external_id: str) -> ApiV2AutoTestsSearchPostRequest:
         autotests_filter = AutoTestSearchApiModelFilter(
             project_ids=[project_id],
             external_ids=[external_id],
@@ -35,38 +38,38 @@ class Converter:
             include_links=False,
             include_labels=False)
 
-        return AdaptersAutoTestsSearchPostRequest(filter=autotests_filter, includes=autotests_includes)
+        return ApiV2AutoTestsSearchPostRequest(filter=autotests_filter, includes=autotests_includes)
 
     @staticmethod
-    def external_ids_to_autotests_search_post_request(
-            external_ids: typing.List[str]) -> AdaptersAutoTestsSearchPostRequest:
+    def autotest_ids_to_autotests_search_post_request(
+            autotest_ids: typing.List[int]) -> ApiV2AutoTestsSearchPostRequest:
         autotests_filter = AutoTestSearchApiModelFilter(
-            external_ids=external_ids,
-            is_deleted=False)
+            global_ids=autotest_ids)
         autotests_includes = AutoTestSearchApiModelIncludes(
             include_steps=False,
             include_links=False,
             include_labels=False)
 
-        return AdaptersAutoTestsSearchPostRequest(filter=autotests_filter, includes=autotests_includes)
+        return ApiV2AutoTestsSearchPostRequest(filter=autotests_filter, includes=autotests_includes)
 
     @staticmethod
     def testrun_id_and_configuration_id_and_in_progress_outcome_to_test_results_search_post_request(
             testrun_id: str,
-            configuration_id: str) -> AdaptersTestResultsSearchPostRequest:
-        return AdaptersTestResultsSearchPostRequest(
+            configuration_id: str) -> ApiV2TestResultsSearchPostRequest:
+        return ApiV2TestResultsSearchPostRequest(
             test_run_ids=[testrun_id],
             configuration_ids=[configuration_id],
             status_types=[TestStatusApiType("InProgress")])
 
     @staticmethod
-    def test_result_short_models_to_autotest_external_ids(
-            test_results: typing.List[TestResultShortResponse]) -> typing.List[str]:
-        return [
-            test_result.autotest_external_id
-            for test_result in test_results
-            if test_result.autotest_external_id
-        ]
+    def test_result_short_get_models_to_autotest_ids(
+            test_results: typing.List[TestResultShortResponse]) -> typing.List[int]:
+        autotest_ids = []
+
+        for test_result in test_results:
+            autotest_ids.append(test_result.autotest_global_id)
+
+        return autotest_ids
 
     @staticmethod
     def autotest_models_to_external_keys(
@@ -85,8 +88,8 @@ class Converter:
 
     @staticmethod
     def test_result_to_create_autotest_request(
-            result: TestCase, external_id: str, project_id: str) -> AdaptersAutoTestsPostRequest:
-        return AdaptersAutoTestsPostRequest(
+            result: TestCase, external_id: str, project_id: str) -> CreateAutoTestRequest:
+        return CreateAutoTestRequest(
             external_id=external_id,
             project_id=project_id,
             name=result.get_name(),
@@ -96,8 +99,8 @@ class Converter:
 
     @staticmethod
     def test_result_to_update_autotest_request(
-            result: TestCase, external_id: str, project_id: str) -> AdaptersAutoTestsPutRequest:
-        return AdaptersAutoTestsPutRequest(
+            result: TestCase, external_id: str, project_id: str) -> UpdateAutoTestRequest:
+        return UpdateAutoTestRequest(
             external_id=external_id,
             project_id=project_id,
             name=result.get_name(),
@@ -125,18 +128,16 @@ class Converter:
         return model
 
     @classmethod
-    def test_run_api_result_to_test_run(cls, test_run_model: TestRunApiResult) -> TestRun:
-        state = test_run_model.state_name
-        state_value = getattr(state, "value", None) or str(state)
+    def test_run_v2_get_model_to_test_run(cls, test_run_model: TestRunV2ApiResult) -> TestRun:
         return TestRun(
             id=test_run_model.id,
             project_id=test_run_model.project_id,
-            state=state_value,
+            state=test_run_model.state_name.value,
             name=test_run_model.name,
-            description=test_run_model.description or "",
-            launch_source=test_run_model.launch_source or "",
+            description=test_run_model.description,
+            launch_source=test_run_model.launch_source,
             attachments=cls.attachment_models_to_attachment_put_models(test_run_model.attachments),
-            links=cls.link_models_to_update_link_models(test_run_model.links),
+            links=cls.link_models_to_link_put_models(test_run_model.links),
             tags=list(test_run_model.tags) if test_run_model.tags else [],
         )
 
@@ -146,7 +147,7 @@ class Converter:
             attachment_models: typing.List[AttachmentApiResult]) -> typing.List[AssignAttachmentApiModel]:
         attachment_put_models = []
 
-        for attachment_model in attachment_models or []:
+        for attachment_model in attachment_models:
             attachment_put_models.append(
                 cls.attachment_model_to_attachment_put_model(attachment_model))
 
@@ -166,32 +167,36 @@ class Converter:
         return list(map(lambda x: Converter.attachment_put_model_to_assign_attachment(x), attachment_models))
 
     @classmethod
-    def link_models_to_update_link_models(
+    def link_models_to_link_put_models(
             cls,
-            link_models: typing.List[LinkApiResult]) -> typing.List[UpdateLinkApiModel]:
+            link_models: typing.List[LinkApiResult]) -> typing.List[LinkPutModel]:
         link_put_models = []
 
-        for link_model in link_models or []:
+        for link_model in link_models:
             link_put_models.append(
-                cls.link_model_to_update_link_model(link_model))
+                cls.link_model_to_link_put_model(link_model))
 
         return link_put_models
 
     @staticmethod
-    def link_model_to_update_link_model(link_model: LinkApiResult) -> UpdateLinkApiModel:
-        return UpdateLinkApiModel(
+    def link_model_to_link_put_model(link_model: LinkApiResult) -> LinkPutModel:
+        return LinkPutModel(
             url=link_model.url,
             id=link_model.id,
             title=link_model.title,
             description=link_model.description,
             type=link_model.type,
+            has_info=link_model.has_info
         )
 
     @staticmethod
-    def test_run_to_update_request(test_run: TestRun) -> AdaptersTestRunsPutRequest:
-        return AdaptersTestRunsPutRequest(
+    def test_run_to_update_empty_request(test_run: TestRun) -> UpdateEmptyRequest:
+        return UpdateEmptyRequest(
+            # str
             id=test_run.id,
+            # str
             name=test_run.name,
+            # str
             description=test_run.description,
             launch_source=test_run.launch_source,
             attachments=test_run.attachments,

{testit_cli-2.10.3 → testit_cli-2.10.3.post580}/src/testit_cli/dir_worker.py

@@ -1,4 +1,5 @@
 import os
+
 from pathlib import PurePath