testit-cli 2.8.4__tar.gz → 2.9.0__tar.gz

{testit_cli-2.8.4 → testit_cli-2.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: testit-cli
-Version: 2.8.4
+Version: 2.9.0
 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,7 +16,7 @@ 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.5.3
+Requires-Dist: testit-api-client==7.5.5
 Requires-Dist: validators
 Requires-Dist: tqdm
 Requires-Dist: click~=8.0.4

{testit_cli-2.8.4 → testit_cli-2.9.0}/setup.py

@@ -1,6 +1,6 @@
 from setuptools import find_packages, setup
 
-VERSION = "2.8.4"
+VERSION = "2.9.0"
 
 setup(
     name='testit-cli',
@@ -26,7 +26,7 @@ setup(
     py_modules=['testit_cli'],
     packages=find_packages(where='src'),
     package_dir={'': 'src'},
-    install_requires=['testit-api-client==7.5.3', 'validators', 'tqdm', 'click~=8.0.4'],
+    install_requires=['testit-api-client==7.5.5', 'validators', 'tqdm', 'click~=8.0.4'],
     entry_points={
         'console_scripts': [
             'testit = testit_cli.__main__:console_main'

{testit_cli-2.8.4 → testit_cli-2.9.0}/src/testit_cli/apiclient.py

@@ -5,18 +5,29 @@ import typing
 
 from testit_api_client import ApiClient as TmsClient
 from testit_api_client import Configuration
-from testit_api_client.apis import AttachmentsApi, AutoTestsApi, TestRunsApi, TestResultsApi
-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_model import AttachmentModel
-from testit_api_client.model.attachment_put_model import AttachmentPutModel
-from testit_api_client.model.auto_test_model import AutoTestModel
-from testit_api_client.model.auto_test_results_for_test_run_model import AutoTestResultsForTestRunModel
-from testit_api_client.model.create_auto_test_request import CreateAutoTestRequest
-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 TestResultShortResponse, CreateEmptyRequest, AutoTestApiResult
+from testit_api_client.apis import AttachmentsApi, AutoTestsApi, TestRunsApi, TestResultsApi, ProjectsApi, WorkflowsApi
+from testit_api_client.models import (
+    ApiV2AutoTestsSearchPostRequest,
+    ApiV2TestResultsSearchPostRequest,
+    ApiV2TestRunsIdRerunsPostRequest,
+    AttachmentModel,
+    AttachmentPutModel,
+    AutoTestModel,
+    AutoTestResultsForTestRunModel,
+    CreateAutoTestRequest,
+    ManualRerunApiResult,
+    ManualRerunSelectTestResultsApiModelExtractionModel,
+    ManualRerunSelectTestResultsApiModelFilter,
+    TestRunV2ApiResult,
+    UpdateAutoTestRequest,
+    UpdateEmptyRequest,
+    TestResultShortResponse,
+    CreateEmptyRequest,
+    AutoTestApiResult,
+    ProjectModel,
+    WorkflowApiResult,
+    CreateProjectRequest,
+)
 
 from .converter import Converter
 from .models.testrun import TestRun
@@ -40,6 +51,8 @@ class ApiClient:
         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, project_id: str, name: str) -> TestRun:
         """Function creates test run and returns test run id."""
@@ -54,6 +67,55 @@ class ApiClient:
 
         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,
+                       status_codes: list[str] = None,
+                       failure_categories: list[str] = None,
+                       namespace: str = None,
+                       class_name: str = None,
+                       auto_test_global_ids: list[int] = None,
+                       auto_test_tags: list[str] = None,
+                       exclude_auto_test_tags: list[str] = None,
+                       auto_test_name: str = None,
+                       test_result_ids: list[str] = None,
+                       webhook_ids: list[str] = None) -> None:
+        """Function reruns test run and returns manual rerun result."""
+        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,
+            auto_test_tags=auto_test_tags,
+            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, 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=test_result_ids
+        ) if test_result_ids is not None else None
+
+        model = ApiV2TestRunsIdRerunsPostRequest(
+            filter=filter_model,
+            extraction_model=extraction_model,
+            webhook_ids=webhook_ids
+        )
+
+        logging.debug(f"Rerunning test run {test_run_id} with model: {model}")
+
+        result: ManualRerunApiResult = self.__test_run_api.api_v2_test_runs_id_reruns_post(
+            id=test_run_id,
+            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}')
+        logging.debug(f"Test run rerun result: {result}")
+
     def update_test_run(self, test_run: TestRun) -> None:
         """Function updates test run."""
         model: UpdateEmptyRequest = Converter.test_run_to_update_empty_request(test_run)
@@ -178,3 +240,31 @@ class ApiClient:
         logging.debug(f"Got test results: {test_results}")
 
         return test_results
+
+    def __get_project(self, project_id: str) -> ProjectModel:
+        """Function returns ProjectModel."""
+        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.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."""
+        project: ProjectModel = self.__get_project(project_id)
+        workflow: WorkflowApiResult = self.__get_workflow_by_id(project.workflow_id)
+
+        return [status.code for status in workflow.statuses]
+
+    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 = 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.create_project(create_project_request=model)
+
+        logging.info(f'Created new project (ID: {project.id})')
+        logging.debug(f"Project created: {project}")
+
+        return str(project.id)

{testit_cli-2.8.4 → testit_cli-2.9.0}/src/testit_cli/click_commands.py

@@ -76,7 +76,20 @@ class ExtraArgsForOption(click.Option):
 @click.option("-iff", "--ignore-flaky-failure", is_flag=True, help="Ignore status flakyFailure in results")
 def upload_results(url, token, configuration_id, testrun_id, separator, namespace, classname, results, debug, attachments, disable_cert_validation, ignore_flaky_failure):
     """Uploading results from different streams"""
-    config = Config(url, token, "", configuration_id, testrun_id, "", separator, namespace, classname, list(chain.from_iterable(results)), debug, "", list(chain.from_iterable(attachments)), disable_cert_validation, "", ignore_flaky_failure)
+    config = Config(
+        url=url,
+        token=token,
+        configuration_id=configuration_id,
+        testrun_id=testrun_id,
+        separator=separator,
+        namespace=namespace,
+        classname=classname,
+        results=list(chain.from_iterable(results)),
+        is_debug=debug,
+        paths_to_attachments=list(chain.from_iterable(attachments)),
+        disable_cert_validation=disable_cert_validation,
+        ignore_flaky_failure=ignore_flaky_failure,
+    )
     service = ServiceFactory().get(config)
 
     service.upload_results()
@@ -103,9 +116,22 @@ def import_results(url, token, project_id, configuration_id, testrun_id, testrun
     if testrun_id is not None and testrun_name is not None:
         click.echo("Illegal usage: `{}` are mutually exclusive arguments.".format(', '.join(["--testrun-id", "--testrun-name"])), err=True)
 
-    config = Config(url, token, project_id, configuration_id, testrun_id, testrun_name,
-                    separator, namespace, classname, list(chain.from_iterable(results)), debug, "", list(chain.from_iterable(attachments)),
-                    disable_cert_validation, "", ignore_flaky_failure)
+    config = Config(
+        url=url,
+        token=token,
+        project_id=project_id,
+        configuration_id=configuration_id,
+        testrun_id=testrun_id,
+        testrun_name=testrun_name,
+        separator=separator,
+        namespace=namespace,
+        classname=classname,
+        results=list(chain.from_iterable(results)),
+        is_debug=debug,
+        paths_to_attachments=list(chain.from_iterable(attachments)),
+        disable_cert_validation=disable_cert_validation,
+        ignore_flaky_failure=ignore_flaky_failure,
+    )
     service = ServiceFactory().get(config)
 
     service.import_results()
@@ -128,7 +154,16 @@ def testrun():
 @click.option("-dcv", "--disable-cert-validation", is_flag=True, help="Disables certificate validation")
 def create_test_run(url, token, project_id, testrun_name, output, debug, attachments, disable_cert_validation):
     """Creating a new test run"""
-    config = Config(url, token, project_id, "", "", testrun_name, "", "", "", [], debug, output, list(chain.from_iterable(attachments)), disable_cert_validation, "", False)
+    config = Config(
+        url=url,
+        token=token,
+        project_id=project_id,
+        testrun_name=testrun_name,
+        is_debug=debug,
+        output=output,
+        paths_to_attachments=list(chain.from_iterable(attachments)),
+        disable_cert_validation=disable_cert_validation,
+    )
     service = ServiceFactory().get(config)
 
     service.create_test_run()
@@ -143,7 +178,14 @@ def create_test_run(url, token, project_id, testrun_name, output, debug, attachm
 @click.option("-dcv", "--disable-cert-validation", is_flag=True, help="Disables certificate validation")
 def complete_test_run(url, token, testrun_id, debug, attachments, disable_cert_validation):
     """Completing the test run"""
-    config = Config(url, token, "", "", testrun_id, "", "", "", "", [], debug, "", list(chain.from_iterable(attachments)), disable_cert_validation, "", False)
+    config = Config(
+        url=url,
+        token=token,
+        testrun_id=testrun_id,
+        is_debug=debug,
+        paths_to_attachments=list(chain.from_iterable(attachments)),
+        disable_cert_validation=disable_cert_validation,
+    )
     service = ServiceFactory().get(config)
 
     service.finished_test_run()
@@ -158,12 +200,63 @@ def complete_test_run(url, token, testrun_id, debug, attachments, disable_cert_v
 @click.option("-dcv", "--disable-cert-validation", is_flag=True, help="Disables certificate validation")
 def upload_attachments_for_test_run(url, token, testrun_id, debug, attachments, disable_cert_validation):
     """Uploading attachments for the test run"""
-    config = Config(url, token, "", "", testrun_id, "", "", "", "", [], debug, "", list(chain.from_iterable(attachments)), disable_cert_validation, "", False)
+    config = Config(
+        url=url,
+        token=token,
+        testrun_id=testrun_id,
+        is_debug=debug,
+        paths_to_attachments=list(chain.from_iterable(attachments)),
+        disable_cert_validation=disable_cert_validation,
+    )
     service = ServiceFactory().get(config)
 
     service.upload_attachments_for_test_run()
 
 
+@testrun.command("rerun")
+@click.option("-u", "--url", type=str, envvar='TMS_URL', required=True, help="Set url address of the Test IT instance (https://demo.testit.software)", callback=validate_url)
+@click.option("-t", "--token", type=str, envvar='TMS_TOKEN', required=True, help="Set API token (T2lKd2pLZGI4WHRhaVZUejNl)")
+@click.option("-ti", "--testrun-id", type=str, envvar='TMS_TEST_RUN_ID', required=True, help="Set test run id (3802f329-190c-4617-8bb0-2c3696abeb8f)", callback=validate_uuid)
+@click.option("-ci", "--configuration-id", type=str, envvar='TMS_CONFIGURATION_ID', multiple=True, help="Set configuration id (15dbb164-c1aa-4cbf-830c-8c01ae14f4fb)", callback=validate_uuid)
+@click.option("-sc", "--status-code", type=str, multiple=True, help="Set status code for filtering test results")
+@click.option("-fc", "--failure-category", type=str, multiple=True, help="Set failure category for filtering test results")
+@click.option("-ns", "--namespace", type=str, help="Set namespace for filtering test results")
+@click.option("-cn", "--classname", type=str, help="Set class name for filtering test results")
+@click.option("-atgi", "--autotest-global-id", type=int, multiple=True, help="Set autotest global ID for filtering test results")
+@click.option("-att", "--autotest-tag", type=str, multiple=True, help="Set autotest tag for filtering test results")
+@click.option("-eatt", "--exclude-autotest-tag", type=str, multiple=True, help="Set autotest tag to exclude from filtering test results")
+@click.option("-atn", "--autotest-name", type=str, help="Set autotest name for filtering test results")
+@click.option("-tri", "--test-result-id", type=str, multiple=True, help="Set test result ID for extraction (UUID)", callback=validate_uuid)
+@click.option("-wi", "--webhook-id", type=str, multiple=True, help="Set webhook ID for rerunning (UUID)", callback=validate_uuid)
+@click.option("-d", "--debug", is_flag=True, help="Set debug logs")
+@click.option("-dcv", "--disable-cert-validation", is_flag=True, help="Disables certificate validation")
+def rerun_test_run(url, token, testrun_id, configuration_id, status_code, failure_category,
+                   namespace, classname, autotest_global_id, autotest_tag, exclude_autotest_tag,
+                   autotest_name, test_result_id, webhook_id, debug, disable_cert_validation):
+    """Rerunning the test run"""
+    config = Config(
+        url=url,
+        token=token,
+        testrun_id=testrun_id,
+        is_debug=debug,
+        disable_cert_validation=disable_cert_validation,
+        configuration_ids=list(configuration_id) if configuration_id else None,
+        status_codes=list(status_code) if status_code else None,
+        failure_categories=list(failure_category) if failure_category else None,
+        namespace=namespace,
+        classname=classname,
+        auto_test_global_ids=list(autotest_global_id) if autotest_global_id else None,
+        auto_test_tags=list(autotest_tag) if autotest_tag else None,
+        exclude_auto_test_tags=list(exclude_autotest_tag) if exclude_autotest_tag else None,
+        auto_test_name=autotest_name,
+        test_result_ids=list(test_result_id) if test_result_id else None,
+        webhook_ids=list(webhook_id) if webhook_id else None,
+    )
+    service = ServiceFactory().get(config)
+
+    service.rerun_test_run()
+
+
 PYTHON_FRAMEWORKS = ['pytest', 'robotframework', 'behave', 'nose']
 JAVA_FRAMEWORKS = ['gradle-testng', 'gradle-junit5', 'gradle-junit4', 'gradle-cucumber', 'maven-testng', 'maven-junit5', 'maven-junit4', 'maven-cucumber']
 KOTLIN_FRAMEWORKS = ['kotest']
@@ -184,7 +277,50 @@ SWIFT_FRAMEWORKS = ['xctest']
 @click.option("-dcv", "--disable-cert-validation", is_flag=True, help="Disables certificate validation")
 def create_filter_for_framework(url, token, configuration_id, testrun_id, framework, debug, output, disable_cert_validation):
     """Creating filter by autotests for test frameworks"""
-    config = Config(url, token, "", configuration_id, testrun_id, "", "", "", "", [], debug, output, [], disable_cert_validation, framework, False)
+    config = Config(
+        url=url,
+        token=token,
+        configuration_id=configuration_id,
+        testrun_id=testrun_id,
+        is_debug=debug,
+        output=output,
+        disable_cert_validation=disable_cert_validation,
+        framework=framework,
+    )
     service = ServiceFactory().get(config)
 
     service.create_filter_for_test_framework()
+
+
+@execute.group()
+def project():
+    """Working with projects"""
+    pass
+
+
+@project.command("create")
+@click.option("-u", "--url", type=str, envvar='TMS_URL', required=True, help="Set url address of the Test IT instance (https://demo.testit.software)", callback=validate_url)
+@click.option("-t", "--token", type=str, envvar='TMS_TOKEN', required=True, help="Set API token (T2lKd2pLZGI4WHRhaVZUejNl)")
+@click.option("-n", "--name", type=str, envvar='TMS_PROJECT_NAME', required=True, help="Set project name (Project01)")
+@click.option("-d", "--description", type=str, help="Set project description (Description of the project)", default=None)
+@click.option("-f", "--favorite", is_flag=True, help="Mark project as favorite")
+@click.option("-wf", "--workflow-id", type=str, help="Set workflow id for the project", default=None)
+@click.option("-o", "--output", type=str, required=True, help="Set file path for output (FILE)")
+@click.option("-d", "--debug", is_flag=True, help="Set debug logs")
+@click.option("-dcv", "--disable-cert-validation", is_flag=True, help="Disables certificate validation")
+def create_project(url, token, name, description, favorite, workflow_id, output, debug, disable_cert_validation):
+    """Creating a new project"""
+    config = Config(
+        url=url,
+        token=token,
+        project_name=name,
+        project_description=description,
+        project_is_favorite=favorite,
+        project_workflow_id=workflow_id,
+        is_debug=debug,
+        output=output,
+        disable_cert_validation=disable_cert_validation,
+    )
+    service = ServiceFactory().get(config)
+
+    service.create_project()

{testit_cli-2.8.4 → testit_cli-2.9.0}/src/testit_cli/converter.py

@@ -15,7 +15,8 @@ from testit_api_client.models import (
     AutoTestResultsForTestRunModel,
     AttachmentPutModel,
     LinkPutModel,
-    TestResultOutcome,
+    TestStatusType,
+    TestStatusApiType,
     TestResultShortResponse,
 )
 from testit_api_client.model.assign_attachment_api_model import AssignAttachmentApiModel
@@ -58,7 +59,7 @@ class Converter:
         return ApiV2TestResultsSearchPostRequest(
             test_run_ids=[testrun_id],
             configuration_ids=[configuration_id],
-            outcomes=[TestResultOutcome("InProgress")])
+            status_types=[TestStatusApiType("InProgress")])
 
     @staticmethod
     def test_result_short_get_models_to_autotest_ids(
@@ -110,17 +111,22 @@ class Converter:
 
     @staticmethod
     def test_result_to_testrun_result_post_model(
-        result: TestCase, external_id: str, configuration_id: str
+        result: TestCase, external_id: str, configuration_id: str, status_codes: typing.List[str]
     ) -> AutoTestResultsForTestRunModel:
-        return AutoTestResultsForTestRunModel(
+        model = AutoTestResultsForTestRunModel(
             configuration_id=configuration_id,
             auto_test_external_id=external_id,
-            outcome=result.get_status(),
+            status_type=TestStatusType(result.get_status_type()),
             traces=result.get_trace(),
             duration=round(result.get_duration()),
             message=result.get_message(),
         )
 
+        if result.get_status().upper() in status_codes:
+            model.status_code = result.get_status()
+
+        return model
+
     @classmethod
     def test_run_v2_get_model_to_test_run(cls, test_run_model: TestRunV2ApiResult) -> TestRun:
         return TestRun(

{testit_cli-2.8.4 → testit_cli-2.9.0}/src/testit_cli/importer.py

@@ -1,4 +1,5 @@
 import hashlib
+import typing
 
 from testit_api_client.model.api_v2_auto_tests_search_post_request import ApiV2AutoTestsSearchPostRequest
 from testit_api_client.model.auto_test_api_result import AutoTestApiResult
@@ -15,7 +16,9 @@ class Importer:
         self.__api_client = api_client
         self.__config = config
 
-    def send_results(self, results: list[TestCase]) -> None:
+    def send_results(self, results: typing.List[TestCase]) -> None:
+        status_codes = self.__api_client.get_status_codes(self.__config.project_id)
+
         for result in tqdm(results, desc="Uploading"):
             external_id = self.__get_external_id(
                 result.get_name_space()
@@ -46,7 +49,7 @@ class Importer:
             self.__api_client.send_test_result(
                 self.__config.testrun_id,
                 Converter.test_result_to_testrun_result_post_model(
-                    result, external_id, self.__config.configuration_id
+                    result, external_id, self.__config.configuration_id, status_codes
                 ),
             )
 

testit_cli-2.9.0/src/testit_cli/models/config.py

@@ -0,0 +1,35 @@
+from dataclasses import dataclass, field
+import typing
+
+
+@dataclass
+class Config:
+    url: str
+    token: str
+    project_id: str = ""
+    project_name: str = ""
+    project_description: typing.Optional[str] = None
+    project_is_favorite: bool = False
+    project_workflow_id: typing.Optional[str] = None
+    configuration_id: str = ""
+    configuration_ids: typing.Optional[list[str]] = None
+    testrun_id: typing.Optional[str] = None
+    testrun_name: typing.Optional[str] = None
+    separator: typing.Optional[str] = None
+    namespace: typing.Optional[str] = None
+    classname: typing.Optional[str] = None
+    status_codes: typing.Optional[list[str]] = None
+    failure_categories: typing.Optional[list[str]] = None
+    auto_test_global_ids: typing.Optional[list[int]] = None
+    auto_test_tags: typing.Optional[list[str]] = None
+    exclude_auto_test_tags: typing.Optional[list[str]] = None
+    auto_test_name: typing.Optional[str] = None
+    test_result_ids: typing.Optional[list[str]] = None
+    webhook_ids: typing.Optional[list[str]] = None
+    results: list[typing.Any] = field(default_factory=list)
+    is_debug: bool = False
+    output: str = ""
+    paths_to_attachments: list[typing.Any] = field(default_factory=list)
+    disable_cert_validation: bool = False
+    framework: str = ""
+    ignore_flaky_failure: bool = False

testit_cli-2.9.0/src/testit_cli/models/status_type.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+
+class StatusType(Enum):
+    SUCCEEDED = 'Succeeded'
+    FAILED = 'Failed'
+    INCOMPLETE = 'Incomplete'
+    INPROGRESS = 'InProgress'
+    PENDING = 'Pending'

{testit_cli-2.8.4 → testit_cli-2.9.0}/src/testit_cli/models/testcase.py

@@ -1,9 +1,7 @@
 from datetime import timedelta
 from typing import Optional
 
-from testit_api_client.models import AvailableTestResultOutcome
-
-from .status import Status
+from .status_type import StatusType
 
 
 class TestCase:
@@ -11,7 +9,8 @@ class TestCase:
     __name_space: Optional[str] = None
     __class_name: Optional[str] = None
     __duration: Optional[timedelta] = None
-    __status: Optional[Status] = None
+    __status: Optional[str] = None
+    __status_type: Optional[StatusType] = None
     __message: Optional[str] = None
     __trace: Optional[str] = None
     __is_flaky: Optional[bool] = None
@@ -21,7 +20,8 @@ class TestCase:
         self.__name_space = name_space
         self.__class_name = class_name
         self.__duration = timedelta(seconds=float(duration))
-        self.__status = Status.PASSED
+        self.__status = "passed"
+        self.__status_type = StatusType.SUCCEEDED
         self.__trace = ""
 
     def get_name(self) -> Optional[str]:
@@ -48,12 +48,18 @@ class TestCase:
     def set_trace(self, value: str) -> None:
         self.__trace = value
 
-    def get_status(self) -> AvailableTestResultOutcome:
-        return AvailableTestResultOutcome(self.__status.value)
+    def get_status(self) -> str:
+        return self.__status
 
-    def set_status(self, value: Status) -> None:
+    def set_status(self, value: str) -> None:
         self.__status = value
 
+    def get_status_type(self) -> StatusType:
+        return self.__status_type
+
+    def set_status_type(self, value: StatusType) -> None:
+        self.__status_type = value
+
     def get_is_flaky(self) -> Optional[bool]:
         return self.__is_flaky
 

{testit_cli-2.8.4 → testit_cli-2.9.0}/src/testit_cli/parser.py

@@ -3,7 +3,7 @@ import typing
 from xml.dom import minidom
 
 from .models.config import Config
-from .models.status import Status
+from .models.status_type import StatusType
 from .models.testcase import TestCase
 from .file_worker import FileWorker
 
@@ -64,11 +64,13 @@ class Parser:
 
                 if elem.childNodes is not None:
                     for child in elem.childNodes:
+                        testcase.set_status(child.nodeName)
+
                         if child.attributes and self.__MESSAGE_ATTRIBUTE_NAME in child.attributes:
                             testcase.set_message(child.attributes[self.__MESSAGE_ATTRIBUTE_NAME].value)
 
                         if child.nodeName == "skipped":
-                            testcase.set_status(Status.SKIPPED)
+                            testcase.set_status_type(StatusType.INCOMPLETE)
                             continue
 
                         # if in failure node names and not flaky
@@ -79,7 +81,7 @@ class Parser:
                             if len(child.childNodes) == 0 and len(child.attributes) == 0:
                                 continue
 
-                            testcase.set_status(Status.FAILED)
+                            testcase.set_status_type(StatusType.FAILED)
 
                         testcase.set_trace(
                             testcase.get_trace() + self.__form_trace(child.childNodes))

{testit_cli-2.8.4 → testit_cli-2.9.0}/src/testit_cli/service.py

@@ -43,6 +43,22 @@ class Service:
 
         self.__write_to_output(test_run.id)
 
+    def rerun_test_run(self) -> None:
+        self.__api_client.rerun_test_run(
+            self.__config.testrun_id,
+            configuration_ids=self.__config.configuration_ids,
+            status_codes=self.__config.status_codes,
+            failure_categories=self.__config.failure_categories,
+            namespace=self.__config.namespace,
+            class_name=self.__config.classname,
+            auto_test_global_ids=self.__config.auto_test_global_ids,
+            auto_test_tags=self.__config.auto_test_tags,
+            exclude_auto_test_tags=self.__config.exclude_auto_test_tags,
+            auto_test_name=self.__config.auto_test_name,
+            test_result_ids=self.__config.test_result_ids,
+            webhook_ids=self.__config.webhook_ids
+        )
+
     def finished_test_run(self):
         test_run = self.__api_client.get_test_run(self.__config.testrun_id)
         self.__update_test_run_with_attachments(test_run)
@@ -103,3 +119,13 @@ class Service:
         autotests_filter = self.__autotests_filter.create_filter()
 
         self.__write_to_output(autotests_filter)
+
+    def create_project(self):
+        project_id = self.__api_client.create_project(
+            self.__config.project_name,
+            self.__config.project_description,
+            self.__config.project_is_favorite,
+            self.__config.project_workflow_id
+        )
+
+        self.__write_to_output(project_id)

testit_cli-2.9.0/src/testit_cli/validation.py

@@ -0,0 +1,29 @@
+import click
+import validators
+
+
+def validate_uuid(ctx, param, value):
+    if value is None:
+        return value
+    if isinstance(value, (tuple, list)):
+        if len(value) == 0:
+            return value
+        for item in value:
+            if item is not None and not validators.uuid(item):
+                raise click.BadParameter(
+                    f'"{item}" uuid of {param.name} (3802f329-190c-4617-8bb0-2c3696abeb8f)'
+                )
+        return value
+    if not validators.uuid(value):
+        raise click.BadParameter(f'"{value}" uuid of {param.name} (3802f329-190c-4617-8bb0-2c3696abeb8f)')
+    return value
+
+
+def validate_url(ctx, param, value):
+    if not validators.url(value):
+        raise click.BadParameter(f'"{value}" url address of the Test IT instance (https://demo.testit.software)')
+
+    if value.endswith("/"):
+        return value[:-1]
+
+    return value

{testit_cli-2.8.4 → testit_cli-2.9.0}/src/testit_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: testit-cli
-Version: 2.8.4
+Version: 2.9.0
 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,7 +16,7 @@ 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.5.3
+Requires-Dist: testit-api-client==7.5.5
 Requires-Dist: validators
 Requires-Dist: tqdm
 Requires-Dist: click~=8.0.4

{testit_cli-2.8.4 → testit_cli-2.9.0}/src/testit_cli.egg-info/SOURCES.txt

@@ -26,7 +26,7 @@ src/testit_cli.egg-info/top_level.txt
 src/testit_cli/models/__init__.py
 src/testit_cli/models/config.py
 src/testit_cli/models/mode.py
-src/testit_cli/models/status.py
+src/testit_cli/models/status_type.py
 src/testit_cli/models/testcase.py
 src/testit_cli/models/testrun.py
 tests/test_click.py

{testit_cli-2.8.4 → testit_cli-2.9.0}/src/testit_cli.egg-info/requires.txt

@@ -1,4 +1,4 @@
-testit-api-client==7.5.3
+testit-api-client==7.5.5
 validators
 tqdm
 click~=8.0.4

testit_cli-2.9.0/tests/test_click.py

@@ -0,0 +1,59 @@
+import pytest
+
+from tests.cli_support import (
+    assert_exit_code,
+    assert_help_ok,
+    assert_invalid_parameter_value,
+    assert_missing_required_option,
+    invoke,
+)
+from tests.helper import Helper
+
+
+@pytest.fixture()
+def runner():
+    from click.testing import CliRunner
+
+    return CliRunner()
+
+
+def test_root_help_lists_known_commands(runner):
+    result = invoke(runner, [])
+    assert_help_ok(result, "Commands:")
+    for line in Helper.root_help_command_lines():
+        assert line in result.output
+
+
+@pytest.mark.parametrize("argv, unknown_token", Helper.unknown_subcommand_cases())
+def test_unknown_command_reports_error(runner, argv, unknown_token):
+    result = invoke(runner, argv)
+    assert_exit_code(result, 2)
+    assert f"No such command '{unknown_token}'" in result.output
+
+
+@pytest.mark.parametrize("argv, command_lines", Helper.subgroup_help_cases())
+def test_subgroup_help_lists_nested_commands(runner, argv, command_lines):
+    result = invoke(runner, argv)
+    assert_help_ok(result, "Commands:")
+    for fragment in command_lines:
+        assert fragment in result.output
+
+
+@pytest.mark.parametrize("argv, missing_long_option", Helper.missing_required_option_cases())
+def test_missing_required_option(runner, argv, missing_long_option):
+    assert_missing_required_option(invoke(runner, argv), missing_long_option)
+
+
+@pytest.mark.parametrize("argv", Helper.invalid_option_cases())
+def test_unrecognized_option_exits_with_usage_error(runner, argv):
+    assert_exit_code(invoke(runner, argv), 2)
+
+
+@pytest.mark.parametrize("argv, doc_fragment", Helper.command_help_doc_cases())
+def test_command_help_includes_description(runner, argv, doc_fragment):
+    assert_help_ok(invoke(runner, argv), doc_fragment)
+
+
+@pytest.mark.parametrize("argv, option_hint", Helper.invalid_rerun_uuid_multi_option_cases())
+def test_rerun_rejects_invalid_uuid_for_optional_multi_options(runner, argv, option_hint):
+    assert_invalid_parameter_value(invoke(runner, argv), option_hint)

testit_cli-2.9.0/tests/test_service.py

@@ -0,0 +1,105 @@
+import os
+import tempfile
+
+import pytest
+from unittest.mock import Mock
+
+from src.testit_cli.service import Service
+from src.testit_cli.models.config import Config
+
+
+@pytest.fixture
+def mock_config():
+    return Mock(spec=Config)
+
+
+@pytest.fixture
+def api_client():
+    return Mock()
+
+
+@pytest.fixture
+def service(mock_config, api_client):
+    return Service(
+        config=mock_config,
+        api_client=api_client,
+        parser=Mock(),
+        importer=Mock(),
+        autotests_filter=Mock(),
+    )
+
+
+def _assert_utf8_file_equals(path: str, expected: str) -> None:
+    with open(path, "r", encoding="utf-8") as f:
+        assert f.read() == expected
+    with open(path, "rb") as f:
+        assert f.read().decode("utf-8") == expected
+
+
+def test_write_to_output_uses_utf8_encoding(service, mock_config):
+    # Deliberate non-ASCII payload to assert UTF-8 read/write round-trip.
+    content = "Тестовый контент с кириллицей: АБВГД абвгд"
+    with tempfile.NamedTemporaryFile(mode="w", delete=False, encoding="utf-8") as tmp:
+        path = tmp.name
+    mock_config.output = path
+    try:
+        service._Service__write_to_output(content)
+        _assert_utf8_file_equals(path, content)
+    finally:
+        if os.path.exists(path):
+            os.unlink(path)
+
+
+def test_write_to_output_creates_parent_directory(service, mock_config):
+    with tempfile.TemporaryDirectory() as tmp_dir:
+        path = os.path.join(tmp_dir, "nested", "out.txt")
+        mock_config.output = path
+        service._Service__write_to_output("test content")
+        assert os.path.isfile(path)
+        _assert_utf8_file_equals(path, "test content")
+
+
+def test_rerun_test_run_forwards_config_to_api_client(service, mock_config, api_client):
+    mock_config.testrun_id = "3802f329-190c-4617-8bb0-2c3696abeb8f"
+    mock_config.configuration_ids = [
+        "15dbb164-c1aa-4cbf-830c-8c01ae14f4fb",
+        "5236eb3f-7c05-46f9-a609-dc0278896464",
+    ]
+    mock_config.status_codes = ["Failed"]
+    mock_config.failure_categories = ["cat-1"]
+    mock_config.namespace = "ns"
+    mock_config.classname = "MyClass"
+    mock_config.auto_test_global_ids = [10, 20]
+    mock_config.auto_test_tags = ["smoke"]
+    mock_config.exclude_auto_test_tags = ["slow"]
+    mock_config.auto_test_name = "test-name"
+    mock_config.test_result_ids = [
+        "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa",
+        "bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb",
+    ]
+    mock_config.webhook_ids = [
+        "cccccccc-cccc-4ccc-8ccc-cccccccccccc",
+    ]
+
+    service.rerun_test_run()
+
+    api_client.rerun_test_run.assert_called_once_with(
+        "3802f329-190c-4617-8bb0-2c3696abeb8f",
+        configuration_ids=[
+            "15dbb164-c1aa-4cbf-830c-8c01ae14f4fb",
+            "5236eb3f-7c05-46f9-a609-dc0278896464",
+        ],
+        status_codes=["Failed"],
+        failure_categories=["cat-1"],
+        namespace="ns",
+        class_name="MyClass",
+        auto_test_global_ids=[10, 20],
+        auto_test_tags=["smoke"],
+        exclude_auto_test_tags=["slow"],
+        auto_test_name="test-name",
+        test_result_ids=[
+            "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa",
+            "bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb",
+        ],
+        webhook_ids=["cccccccc-cccc-4ccc-8ccc-cccccccccccc"],
+    )

testit_cli-2.8.4/src/testit_cli/models/config.py

@@ -1,22 +0,0 @@
-from dataclasses import dataclass
-import typing
-
-
-@dataclass
-class Config:
-    url: str
-    token: str
-    project_id: str
-    configuration_id: str
-    testrun_id: str
-    testrun_name: str
-    separator: str
-    namespace: str
-    classname: str
-    results: list[typing.Any]
-    is_debug: bool
-    output: str
-    paths_to_attachments: list[typing.Any]
-    disable_cert_validation: bool
-    framework: str
-    ignore_flaky_failure: bool

testit_cli-2.8.4/src/testit_cli/models/status.py

@@ -1,7 +0,0 @@
-from enum import Enum
-
-
-class Status(Enum):
-    PASSED = "Passed"
-    FAILED = "Failed"
-    SKIPPED = "Skipped"

testit_cli-2.8.4/src/testit_cli/validation.py

@@ -1,20 +0,0 @@
-import click
-import validators
-
-
-def validate_uuid(ctx, param, value):
-    if value is not None:
-        if not validators.uuid(value):
-            raise click.BadParameter(f'"{value}" uuid of {param.name} (3802f329-190c-4617-8bb0-2c3696abeb8f)')
-
-    return value
-
-
-def validate_url(ctx, param, value):
-    if not validators.url(value):
-        raise click.BadParameter(f'"{value}" url address of the Test IT instance (https://demo.testit.software)')
-
-    if value.endswith("/"):
-        return value[:-1]
-
-    return value

testit_cli-2.8.4/tests/test_click.py

@@ -1,136 +0,0 @@
-from click.testing import CliRunner
-import pytest
-
-from src.testit_cli.click_commands import execute
-from tests.helper import Helper
-
-
-@pytest.fixture()
-def runner():
-    return CliRunner()
-
-
-def test_run_without_command(runner):
-    message = ("Options:\n  --help  Show this message and exit.\n\nCommands:\n  autotests_filter  "
-               "Creating filter by autotests for test frameworks\n  results           "
-               "Uploading the test results\n  testrun           Working with the test run\n")
-    result = runner.invoke(execute, [])
-
-    assert message in result.output
-    assert result.exit_code == 0
-
-
-def test_run_with_another_command(runner):
-    another_command = "run"
-    message = f"Error: No such command '{another_command}'"
-    result = runner.invoke(execute, [another_command])
-
-    assert message in result.output
-    assert result.exit_code == 2
-
-
-@pytest.mark.parametrize("command, message", [
-    ("results", "Options:\n  --help  Show this message and exit.\n\nCommands:\n  import  Uploading the first test results\n  upload  Uploading results from different streams\n"),
-    ("testrun", "Options:\n  --help  Show this message and exit.\n\nCommands:\n  complete            Completing the test run\n  create              Creating a new test run\n  upload_attachments  Uploading attachments for the test run\n")])
-def test_run_with_command(runner, command, message):
-    result = runner.invoke(execute, [command])
-
-    assert message in result.output
-    assert result.exit_code == 0
-
-
-def test_run_results_with_another_command(runner):
-    another_command = "run"
-    message = f"Error: No such command '{another_command}'"
-    result = runner.invoke(execute, ["results", another_command])
-
-    assert message in result.output
-    assert result.exit_code == 2
-
-
-@pytest.mark.parametrize("commands, output", [
-    (Helper.get_command_results_import_with_long_arguments_without_url_argument(), Helper.get_output_for_results_import_without_url_argument()),
-    (Helper.get_command_results_import_with_short_arguments_without_url_argument(), Helper.get_output_for_results_import_without_url_argument()),
-    (Helper.get_command_results_import_with_long_arguments_without_token_argument(), Helper.get_output_for_results_import_without_token_argument()),
-    (Helper.get_command_results_import_with_short_arguments_without_token_argument(), Helper.get_output_for_results_import_without_token_argument()),
-    (Helper.get_command_results_import_with_long_arguments_without_project_id_argument(), Helper.get_output_for_results_import_without_project_id_argument()),
-    (Helper.get_command_results_import_with_short_arguments_without_project_id_argument(), Helper.get_output_for_results_import_without_project_id_argument()),
-    (Helper.get_command_results_import_with_long_arguments_without_configuration_id_argument(), Helper.get_output_for_results_import_without_configuration_id_argument()),
-    (Helper.get_command_results_import_with_short_arguments_without_configuration_id_argument(), Helper.get_output_for_results_import_without_configuration_id_argument()),
-    (Helper.get_command_results_import_with_long_arguments_without_results_argument(), Helper.get_output_for_results_import_without_results_argument()),
-    (Helper.get_command_results_import_with_short_arguments_without_results_argument(), Helper.get_output_for_results_import_without_results_argument()),
-    (Helper.get_command_results_upload_with_long_arguments_without_url_argument(), Helper.get_output_for_results_upload_without_url_argument()),
-    (Helper.get_command_results_upload_with_short_arguments_without_url_argument(), Helper.get_output_for_results_upload_without_url_argument()),
-    (Helper.get_command_results_upload_with_long_arguments_without_token_argument(), Helper.get_output_for_results_upload_without_token_argument()),
-    (Helper.get_command_results_upload_with_short_arguments_without_token_argument(), Helper.get_output_for_results_upload_without_token_argument()),
-    (Helper.get_command_results_upload_with_long_arguments_without_testrun_id_argument(), Helper.get_output_for_results_upload_without_testrun_id_argument()),
-    (Helper.get_command_results_upload_with_short_arguments_without_testrun_id_argument(), Helper.get_output_for_results_upload_without_testrun_id_argument()),
-    (Helper.get_command_results_upload_with_long_arguments_without_configuration_id_argument(), Helper.get_output_for_results_upload_without_configuration_id_argument()),
-    (Helper.get_command_results_upload_with_short_arguments_without_configuration_id_argument(), Helper.get_output_for_results_upload_without_configuration_id_argument()),
-    (Helper.get_command_results_upload_with_long_arguments_without_results_argument(), Helper.get_output_for_results_upload_without_results_argument()),
-    (Helper.get_command_results_upload_with_short_arguments_without_results_argument(), Helper.get_output_for_results_upload_without_results_argument()),
-    (Helper.get_command_testrun_create_with_long_arguments_without_url_argument(), Helper.get_output_for_testrun_create_without_url_argument()),
-    (Helper.get_command_testrun_create_with_short_arguments_without_url_argument(), Helper.get_output_for_testrun_create_without_url_argument()),
-    (Helper.get_command_testrun_create_with_long_arguments_without_token_argument(), Helper.get_output_for_testrun_create_without_token_argument()),
-    (Helper.get_command_testrun_create_with_short_arguments_without_token_argument(), Helper.get_output_for_testrun_create_without_token_argument()),
-    (Helper.get_command_testrun_create_with_long_arguments_without_project_id_argument(), Helper.get_output_for_testrun_create_without_project_id_argument()),
-    (Helper.get_command_testrun_create_with_short_arguments_without_project_id_argument(), Helper.get_output_for_testrun_create_without_project_id_argument()),
-    (Helper.get_command_testrun_create_with_long_arguments_without_output_argument(), Helper.get_output_for_testrun_create_without_output_argument()),
-    (Helper.get_command_testrun_create_with_short_arguments_without_output_argument(), Helper.get_output_for_testrun_create_without_output_argument()),
-    (Helper.get_command_testrun_complete_with_long_arguments_without_url_argument(), Helper.get_output_for_testrun_complete_without_url_argument()),
-    (Helper.get_command_testrun_complete_with_short_arguments_without_url_argument(), Helper.get_output_for_testrun_complete_without_url_argument()),
-    (Helper.get_command_testrun_complete_with_long_arguments_without_token_argument(), Helper.get_output_for_testrun_complete_without_token_argument()),
-    (Helper.get_command_testrun_complete_with_short_arguments_without_token_argument(), Helper.get_output_for_testrun_complete_without_token_argument()),
-    (Helper.get_command_testrun_complete_with_long_arguments_without_testrun_id_argument(), Helper.get_output_for_testrun_complete_without_testrun_id_argument()),
-    (Helper.get_command_testrun_complete_with_short_arguments_without_testrun_id_argument(), Helper.get_output_for_testrun_complete_without_testrun_id_argument()),
-    (Helper.get_command_testrun_upload_attachments_with_long_arguments_without_url_argument(), Helper.get_output_for_testrun_upload_attachments_without_url_argument()),
-    (Helper.get_command_testrun_upload_attachments_with_short_arguments_without_url_argument(), Helper.get_output_for_testrun_upload_attachments_without_url_argument()),
-    (Helper.get_command_testrun_upload_attachments_with_long_arguments_without_token_argument(), Helper.get_output_for_testrun_upload_attachments_without_token_argument()),
-    (Helper.get_command_testrun_upload_attachments_with_short_arguments_without_token_argument(), Helper.get_output_for_testrun_upload_attachments_without_token_argument()),
-    (Helper.get_command_testrun_upload_attachments_with_long_arguments_without_testrun_id_argument(), Helper.get_output_for_testrun_upload_attachments_without_testrun_id_argument()),
-    (Helper.get_command_testrun_upload_attachments_with_short_arguments_without_testrun_id_argument(), Helper.get_output_for_testrun_upload_attachments_without_testrun_id_argument())])
-def test_run_results_with_command_without_arguments(runner, commands, output):
-    result = runner.invoke(execute, commands)
-
-    assert output in result.output
-    assert result.exit_code == 2
-
-# TODO: inifinite loading, fix
-
-# @pytest.mark.parametrize("commands_with_args", [
-#     Helper.get_command_results_import_with_long_arguments(),
-#     Helper.get_command_results_upload_with_long_arguments(),
-#     Helper.get_command_results_import_with_short_arguments(),
-#     Helper.get_command_results_upload_with_short_arguments(),
-#     Helper.get_command_results_import_with_all_long_arguments(),
-#     Helper.get_command_results_upload_with_all_long_arguments(),
-#     Helper.get_command_results_import_with_all_short_arguments(),
-#     Helper.get_command_results_upload_with_all_short_arguments(),
-#     Helper.get_command_testrun_complete_with_long_arguments(),
-#     Helper.get_command_testrun_create_with_long_arguments(),
-#     Helper.get_command_testrun_upload_attachments_with_long_arguments(),
-#     Helper.get_command_testrun_complete_with_short_arguments(),
-#     Helper.get_command_testrun_create_with_short_arguments(),
-#     Helper.get_command_testrun_upload_attachments_with_short_arguments(),
-#     Helper.get_command_testrun_complete_with_all_long_arguments(),
-#     Helper.get_command_testrun_create_with_all_long_arguments(),
-#     Helper.get_command_testrun_upload_attachments_with_all_long_arguments(),
-#     Helper.get_command_testrun_complete_with_all_short_arguments(),
-#     Helper.get_command_testrun_create_with_all_short_arguments(),
-#     Helper.get_command_testrun_upload_attachments_with_all_short_arguments()])
-# def test_run_with_commands_and_arguments(runner, commands_with_args):
-#     result = runner.invoke(execute, commands_with_args)
-
-#     assert result.exit_code == 1
-
-
-@pytest.mark.parametrize("commands_with_another_arg", [
-    Helper.get_command_results_upload_with_another_argument(),
-    Helper.get_command_results_import_with_another_argument(),
-    Helper.get_command_testrun_complete_with_another_argument(),
-    Helper.get_command_testrun_create_with_another_argument(),
-    Helper.get_command_testrun_upload_attachments_with_another_argument()])
-def test_run_with_command_and_another_argument(runner, commands_with_another_arg):
-    result = runner.invoke(execute, commands_with_another_arg)
-
-    assert result.exit_code == 2

testit_cli-2.8.4/tests/test_service.py

@@ -1,79 +0,0 @@
-import os
-import tempfile
-import pytest
-from unittest.mock import Mock
-
-from src.testit_cli.service import Service
-from src.testit_cli.models.config import Config
-
-
-@pytest.fixture
-def mock_config():
-    """Fixture for creating mock config object"""
-    config = Mock(spec=Config)
-    return config
-
-
-@pytest.fixture  
-def service(mock_config):
-    """Fixture for creating Service instance with mock dependencies"""
-    api_client = Mock()
-    parser = Mock()
-    importer = Mock()
-    autotests_filter = Mock()
-    
-    return Service(
-        config=mock_config,
-        api_client=api_client,
-        parser=parser,
-        importer=importer,
-        autotests_filter=autotests_filter
-    )
-
-
-def test_write_to_output_uses_utf8_encoding(service, mock_config):
-    """Test verifies that file is written using UTF-8 encoding"""
-    # Arrange
-    cyrillic_content = "Тестовый контент с кириллицей: АБВГД абвгд"
-    
-    with tempfile.NamedTemporaryFile(mode='w', delete=False, encoding='utf-8') as temp_file:
-        temp_output_path = temp_file.name
-    
-    mock_config.output = temp_output_path
-    
-    try:
-        # Act - call private method using name mangling
-        service._Service__write_to_output(cyrillic_content)
-        
-        # Assert - verify file is written in UTF-8
-        with open(temp_output_path, 'r', encoding='utf-8') as file:
-            written_content = file.read()
-            assert written_content == cyrillic_content
-            
-        # Additional check - read as bytes and verify UTF-8 BOM is absent
-        with open(temp_output_path, 'rb') as file:
-            raw_content = file.read()
-            # Verify content can be decoded as UTF-8
-            decoded_content = raw_content.decode('utf-8')
-            assert decoded_content == cyrillic_content
-            
-    finally:
-        # Cleanup
-        if os.path.exists(temp_output_path):
-            os.unlink(temp_output_path)
-
-
-def test_write_to_output_creates_directory(service, mock_config):
-    """Test verifies that directory is created if it doesn't exist"""
-    # Arrange  
-    with tempfile.TemporaryDirectory() as temp_dir:
-        output_path = os.path.join(temp_dir, "subdir", "output.txt")
-        mock_config.output = output_path
-        
-        # Act
-        service._Service__write_to_output("test content")
-        
-        # Assert
-        assert os.path.exists(output_path)
-        with open(output_path, 'r', encoding='utf-8') as file:
-            assert file.read() == "test content"