lucius-mcp 0.2.2__py3-none-any.whl → 0.4.0__py3-none-any.whl

src/client/client.py

@@ -10,7 +10,7 @@ from collections.abc import Awaitable
 from typing import Literal, TypeVar, cast, overload
 
 import httpx
-from pydantic import SecretStr
+from pydantic import Field, SecretStr, ValidationError
 
 from src.client.exceptions import TestCaseNotFoundError
 from src.utils.config import settings
@@ -26,27 +26,45 @@ from .exceptions import (
 from .generated.api.custom_field_controller_api import CustomFieldControllerApi
 from .generated.api.custom_field_project_controller_api import CustomFieldProjectControllerApi
 from .generated.api.custom_field_project_controller_v2_api import CustomFieldProjectControllerV2Api
+from .generated.api.custom_field_value_controller_api import CustomFieldValueControllerApi
 from .generated.api.custom_field_value_project_controller_api import CustomFieldValueProjectControllerApi
+from .generated.api.integration_controller_api import IntegrationControllerApi
+from .generated.api.launch_controller_api import LaunchControllerApi
+from .generated.api.launch_search_controller_api import LaunchSearchControllerApi
 from .generated.api.shared_step_attachment_controller_api import SharedStepAttachmentControllerApi
 from .generated.api.shared_step_controller_api import SharedStepControllerApi
 from .generated.api.shared_step_scenario_controller_api import SharedStepScenarioControllerApi
 from .generated.api.test_case_attachment_controller_api import TestCaseAttachmentControllerApi
 from .generated.api.test_case_controller_api import TestCaseControllerApi
-from .generated.api.test_case_custom_field_controller_api import TestCaseCustomFieldControllerApi
 from .generated.api.test_case_overview_controller_api import TestCaseOverviewControllerApi
 from .generated.api.test_case_scenario_controller_api import TestCaseScenarioControllerApi
 from .generated.api.test_case_search_controller_api import TestCaseSearchControllerApi
+from .generated.api.test_layer_controller_api import TestLayerControllerApi
+from .generated.api.test_layer_schema_controller_api import TestLayerSchemaControllerApi
 from .generated.api_client import ApiClient
 from .generated.configuration import Configuration
 from .generated.exceptions import ApiException
+from .generated.models.aql_validate_response_dto import AqlValidateResponseDto
 from .generated.models.attachment_step_dto import AttachmentStepDto
 from .generated.models.body_step_dto import BodyStepDto
 from .generated.models.custom_field_project_with_values_dto import CustomFieldProjectWithValuesDto
+from .generated.models.custom_field_value_project_create_dto import CustomFieldValueProjectCreateDto
+from .generated.models.custom_field_value_project_patch_dto import CustomFieldValueProjectPatchDto
 from .generated.models.custom_field_value_with_cf_dto import CustomFieldValueWithCfDto
+from .generated.models.custom_field_with_values_dto import CustomFieldWithValuesDto
+from .generated.models.find_all29200_response import FindAll29200Response
+from .generated.models.integration_dto import IntegrationDto
+from .generated.models.issue_dto import IssueDto
+from .generated.models.launch_create_dto import LaunchCreateDto
+from .generated.models.launch_dto import LaunchDto
+from .generated.models.page_custom_field_value_with_tc_count_dto import PageCustomFieldValueWithTcCountDto
+from .generated.models.page_launch_dto import PageLaunchDto
+from .generated.models.page_launch_preview_dto import PageLaunchPreviewDto
 from .generated.models.page_shared_step_dto import PageSharedStepDto
 from .generated.models.page_test_case_dto import PageTestCaseDto
 from .generated.models.scenario_step_create_dto import ScenarioStepCreateDto
 from .generated.models.scenario_step_created_response_dto import ScenarioStepCreatedResponseDto
+from .generated.models.scenario_step_patch_dto import ScenarioStepPatchDto
 from .generated.models.shared_step_attachment_row_dto import SharedStepAttachmentRowDto
 from .generated.models.shared_step_create_dto import SharedStepCreateDto
 from .generated.models.shared_step_dto import SharedStepDto
@@ -62,13 +80,18 @@ from .generated.models.test_case_row_dto import TestCaseRowDto
 from .generated.models.test_case_scenario_dto import TestCaseScenarioDto
 from .generated.models.test_case_scenario_v2_dto import TestCaseScenarioV2Dto
 from .generated.models.test_case_tree_selection_dto import TestCaseTreeSelectionDto
+from .overridden.test_case_custom_fields_v2 import TestCaseCustomFieldV2ControllerApi
 
 
 # Subclasses to add missing fields to generated models
 class TestCaseDtoWithCF(TestCaseDto):
-    """Subclass to support custom_fields access."""
+    """Subclass to support custom_fields and issues access."""
 
     custom_fields: list[CustomFieldValueWithCfDto] | None = None
+    issues: list[IssueDto] | None = None
+
+
+TestCaseDtoWithCF.model_rebuild()
 
 
 class BodyStepDtoWithSteps(BodyStepDto):
@@ -78,6 +101,14 @@ class BodyStepDtoWithSteps(BodyStepDto):
     id: int | None = None
 
 
+class StepWithExpected(BodyStepDto):
+    """Subclass to support expected results and nested steps."""
+
+    expected_result: str | None = Field(default=None, alias="expectedResult")
+    steps: list[SharedStepScenarioDtoStepsInner] | None = None
+    id: int | None = None
+
+
 class AttachmentStepDtoWithName(AttachmentStepDto):
     """Subclass to support name attribute and id."""
 
@@ -104,11 +135,17 @@ type ApiType = (
     | SharedStepScenarioControllerApi
     | TestCaseOverviewControllerApi
     | TestCaseSearchControllerApi
-    | TestCaseCustomFieldControllerApi
+    | TestCaseCustomFieldV2ControllerApi
     | CustomFieldControllerApi
     | CustomFieldProjectControllerApi
     | CustomFieldProjectControllerV2Api
+    | CustomFieldValueControllerApi
     | CustomFieldValueProjectControllerApi
+    | TestLayerControllerApi
+    | TestLayerSchemaControllerApi
+    | LaunchControllerApi
+    | LaunchSearchControllerApi
+    | IntegrationControllerApi
 )
 
 type NormalizedScenarioDict = dict[str, object]
@@ -123,16 +160,24 @@ __all__ = [
     "AttachmentStepDtoWithName",
     "BodyStepDtoWithSteps",
     "CustomFieldProjectWithValuesDto",
+    "CustomFieldWithValuesDto",
+    "FindAll29200Response",
+    "LaunchCreateDto",
+    "LaunchDto",
+    "PageLaunchDto",
+    "PageLaunchPreviewDto",
     "PageSharedStepDto",
     "PageTestCaseDto",
     "ScenarioStepCreateDto",
     "ScenarioStepCreatedResponseDto",
+    "ScenarioStepPatchDto",
     "SharedStepAttachmentRowDto",
     "SharedStepCreateDto",
     "SharedStepDto",
     "SharedStepPatchDto",
     "SharedStepScenarioDtoStepsInner",
     "SharedStepStepDtoWithId",
+    "StepWithExpected",
     "TestCaseAttachmentRowDto",
     "TestCaseCreateV2Dto",
     "TestCaseDto",
@@ -204,11 +249,17 @@ class AllureClient:
         self._shared_step_scenario_api: SharedStepScenarioControllerApi | None = None
         self._overview_api: TestCaseOverviewControllerApi
         self._search_api: TestCaseSearchControllerApi | None = None
-        self._test_case_custom_field_api: TestCaseCustomFieldControllerApi | None = None
+        self._test_case_custom_field_api: TestCaseCustomFieldV2ControllerApi | None = None
         self._custom_field_api: CustomFieldControllerApi | None = None
         self._custom_field_project_api: CustomFieldProjectControllerApi | None = None
         self._custom_field_project_v2_api: CustomFieldProjectControllerV2Api | None = None
+        self._custom_field_value_api: CustomFieldValueControllerApi | None = None
         self._custom_field_value_project_api: CustomFieldValueProjectControllerApi | None = None
+        self._test_layer_api: TestLayerControllerApi | None = None
+        self._test_layer_schema_api: TestLayerSchemaControllerApi | None = None
+        self._launch_api: LaunchControllerApi | None = None
+        self._launch_search_api: LaunchSearchControllerApi | None = None
+        self._integration_api: IntegrationControllerApi | None = None
         self._is_entered = False
 
     @classmethod
@@ -239,7 +290,7 @@ class AllureClient:
         if not isinstance(settings.ALLURE_PROJECT_ID, int) or settings.ALLURE_PROJECT_ID <= 0:
             raise ValueError("ALLURE_PROJECT_ID must be a positive integer")
 
-        if project:
+        if project is not None:
             p = project
         else:
             p = settings.ALLURE_PROJECT_ID
@@ -345,11 +396,17 @@ class AllureClient:
             self._shared_step_scenario_api = SharedStepScenarioControllerApi(self._api_client)
             self._overview_api = TestCaseOverviewControllerApi(self._api_client)
             self._search_api = TestCaseSearchControllerApi(self._api_client)
-            self._test_case_custom_field_api = TestCaseCustomFieldControllerApi(self._api_client)
+            self._test_case_custom_field_api = TestCaseCustomFieldV2ControllerApi(self._api_client)
             self._custom_field_api = CustomFieldControllerApi(self._api_client)
             self._custom_field_project_api = CustomFieldProjectControllerApi(self._api_client)
             self._custom_field_project_v2_api = CustomFieldProjectControllerV2Api(self._api_client)
+            self._custom_field_value_api = CustomFieldValueControllerApi(self._api_client)
             self._custom_field_value_project_api = CustomFieldValueProjectControllerApi(self._api_client)
+            self._test_layer_api = TestLayerControllerApi(self._api_client)
+            self._test_layer_schema_api = TestLayerSchemaControllerApi(self._api_client)
+            self._launch_api = LaunchControllerApi(self._api_client)
+            self._launch_search_api = LaunchSearchControllerApi(self._api_client)
+            self._integration_api = IntegrationControllerApi(self._api_client)
 
     @property
     def api_client(self) -> ApiClient:
@@ -362,6 +419,21 @@ class AllureClient:
             raise RuntimeError("AllureClient must be used as an async context manager")
         return self._api_client
 
+    async def get_integrations(self) -> list[IntegrationDto]:
+        """Fetch all integrations."""
+        # Ensure we have a valid client
+        if self._integration_api is None:
+            raise RuntimeError("AllureClient must be used as an async context manager")
+
+        try:
+            # Fetch first page with reasonable size
+            page = await self._integration_api.get_integrations(page=0, size=100)
+            return page.content or []
+        except Exception:
+            # Log warning or re-raise depending on strictness.
+            # For now return empty list to act as fallback.
+            return []
+
     async def __aenter__(self) -> AllureClient:
         """Initialize the client session within an async context.
 
@@ -466,7 +538,7 @@ class AllureClient:
     @overload
     async def _get_api(
         self, attr_name: Literal["_test_case_custom_field_api"], *, error_name: str | None = None
-    ) -> TestCaseCustomFieldControllerApi: ...
+    ) -> TestCaseCustomFieldV2ControllerApi: ...
 
     @overload
     async def _get_api(
@@ -483,11 +555,26 @@ class AllureClient:
         self, attr_name: Literal["_custom_field_project_v2_api"], *, error_name: str | None = None
     ) -> CustomFieldProjectControllerV2Api: ...
 
+    @overload
+    async def _get_api(
+        self, attr_name: Literal["_custom_field_value_api"], *, error_name: str | None = None
+    ) -> CustomFieldValueControllerApi: ...
+
     @overload
     async def _get_api(
         self, attr_name: Literal["_custom_field_value_project_api"], *, error_name: str | None = None
     ) -> CustomFieldValueProjectControllerApi: ...
 
+    @overload
+    async def _get_api(
+        self, attr_name: Literal["_launch_api"], *, error_name: str | None = None
+    ) -> LaunchControllerApi: ...
+
+    @overload
+    async def _get_api(
+        self, attr_name: Literal["_launch_search_api"], *, error_name: str | None = None
+    ) -> LaunchSearchControllerApi: ...
+
     async def _get_api(self, attr_name: str, *, error_name: str | None = None) -> ApiType:
         self._require_entered()
         await self._ensure_valid_token()
@@ -693,6 +780,210 @@ class AllureClient:
             )
         )
 
+    # ==========================================
+    # Launch operations
+    # ==========================================
+
+    async def create_launch(self, data: LaunchCreateDto) -> LaunchDto:
+        """Create a new launch in the specified project.
+
+        Args:
+            data: Launch definition (name, project_id, etc.).
+
+        Returns:
+            The created launch.
+
+        Raises:
+            AllureNotFoundError: If project doesn't exist.
+            AllureValidationError: If input data fails validation.
+            AllureAuthError: If unauthorized.
+            AllureAPIError: If the server returns an error.
+        """
+        api = await self._get_api("_launch_api")
+
+        if hasattr(data, "project_id") and not data.project_id:
+            data.project_id = self._project
+
+        return await self._call_api(api.create31(launch_create_dto=data, _request_timeout=self._timeout))
+
+    async def list_launches(
+        self,
+        project_id: int,
+        page: int = 0,
+        size: int = 20,
+        search: str | None = None,
+        filter_id: int | None = None,
+        sort: list[str] | None = None,
+    ) -> FindAll29200Response:
+        """List launches for a project.
+
+        Args:
+            project_id: Target project ID.
+            page: Zero-based page index.
+            size: Page size.
+            search: Optional name search.
+            filter_id: Optional filter ID.
+            sort: Optional sort criteria.
+
+        Returns:
+            Paginated launches or launch previews.
+
+        Raises:
+            AllureNotFoundError: If project doesn't exist.
+            AllureValidationError: If input data fails validation.
+            AllureAuthError: If unauthorized.
+            AllureAPIError: If the server returns an error.
+        """
+        api = await self._get_api("_launch_api", error_name="launch APIs")
+
+        if not isinstance(project_id, int) or project_id <= 0:
+            raise AllureValidationError("Project ID must be a positive integer")
+        if not isinstance(page, int) or page < 0:
+            raise AllureValidationError("Page must be a non-negative integer")
+        if not isinstance(size, int) or size <= 0 or size > 100:
+            raise AllureValidationError("Size must be between 1 and 100")
+
+        try:
+            return await self._call_api(
+                api.find_all29(
+                    project_id=project_id,
+                    search=search,
+                    filter_id=filter_id,
+                    page=page,
+                    size=size,
+                    sort=sort,
+                    _request_timeout=self._timeout,
+                )
+            )
+        except ValueError:
+            response = await self._call_api_raw(
+                api.find_all29_without_preload_content(
+                    project_id=project_id,
+                    search=search,
+                    filter_id=filter_id,
+                    page=page,
+                    size=size,
+                    sort=sort,
+                    _request_timeout=self._timeout,
+                )
+            )
+            data = self._extract_response_data(response)
+            try:
+                page_data = PageLaunchDto.from_dict(data)
+                if page_data is None:
+                    raise AllureValidationError("Unexpected launch list response from API")
+                return FindAll29200Response(page_data)
+            except ValidationError as e:
+                preview_data = PageLaunchPreviewDto.from_dict(data)
+                if preview_data is None:
+                    raise AllureValidationError("Unexpected launch list response from API") from e
+                return FindAll29200Response(preview_data)
+
+    async def get_launch(self, launch_id: int) -> LaunchDto:
+        """Retrieve a specific launch by its ID.
+
+        Args:
+            launch_id: The unique ID of the launch.
+
+        Returns:
+            The launch data.
+
+        Raises:
+            AllureNotFoundError: If launch doesn't exist.
+            AllureValidationError: If input is invalid.
+            AllureAuthError: If unauthorized.
+            AllureAPIError: If the server returns an error.
+        """
+        api = await self._get_api("_launch_api", error_name="launch APIs")
+
+        if not isinstance(launch_id, int) or launch_id <= 0:
+            raise AllureValidationError("Launch ID must be a positive integer")
+
+        return await self._call_api(api.find_one23(id=launch_id, _request_timeout=self._timeout))
+
+    async def search_launches_aql(
+        self,
+        project_id: int,
+        rql: str,
+        page: int = 0,
+        size: int = 20,
+        sort: list[str] | None = None,
+    ) -> PageLaunchDto:
+        """Search launches using raw AQL (Allure Query Language).
+
+        Args:
+            project_id: Target project ID.
+            rql: Raw AQL query string.
+            page: Zero-based page index.
+            size: Page size (max 100).
+            sort: Optional sort criteria (e.g., ["createdDate,DESC"]).
+
+        Returns:
+            Paginated launch results matching the AQL query.
+
+        Raises:
+            AllureValidationError: If AQL syntax is invalid or input fails validation.
+            AllureNotFoundError: If project doesn't exist.
+            AllureAuthError: If unauthorized.
+            AllureAPIError: If the server returns an error.
+        """
+        api = await self._get_api("_launch_search_api", error_name="launch search APIs")
+
+        if not isinstance(project_id, int) or project_id <= 0:
+            raise AllureValidationError("Project ID must be a positive integer")
+        if not isinstance(rql, str) or not rql.strip():
+            raise AllureValidationError("AQL query must be a non-empty string")
+        if not isinstance(page, int) or page < 0:
+            raise AllureValidationError("Page must be a non-negative integer")
+        if not isinstance(size, int) or size <= 0 or size > 100:
+            raise AllureValidationError("Size must be between 1 and 100")
+
+        return await self._call_api(
+            api.search2(
+                project_id=project_id,
+                rql=rql,
+                page=page,
+                size=size,
+                sort=sort,
+                _request_timeout=self._timeout,
+            )
+        )
+
+    async def validate_launch_query(
+        self,
+        project_id: int,
+        rql: str,
+    ) -> AqlValidateResponseDto:
+        """Validate an AQL query for launches without executing it.
+
+        Args:
+            project_id: Target project ID.
+            rql: Raw AQL query string to validate.
+
+        Returns:
+            Validation response with validity and count.
+
+        Raises:
+            AllureValidationError: If input fails basic validation.
+            AllureNotFoundError: If project doesn't exist.
+            AllureAuthError: If unauthorized.
+            AllureAPIError: If the server returns an error.
+        """
+        api = await self._get_api("_launch_search_api", error_name="launch search APIs")
+
+        if not isinstance(project_id, int) or project_id <= 0:
+            raise AllureValidationError("Project ID must be a positive integer")
+        if not isinstance(rql, str) or not rql.strip():
+            raise AllureValidationError("AQL query must be a non-empty string")
+
+        return await self._call_api(
+            api.validate_query2(
+                project_id=project_id,
+                rql=rql,
+                _request_timeout=self._timeout,
+            )
+        )
+
     async def search_test_cases_aql(
         self,
         project_id: int,
@@ -867,6 +1158,165 @@ class AllureClient:
             with_expected_result=with_expected_result,
         )
 
+    async def list_custom_field_values(
+        self,
+        project_id: int,
+        custom_field_id: int,
+        *,
+        query: str | None = None,
+        var_global: bool | None = None,
+        test_case_search: str | None = None,
+        page: int | None = None,
+        size: int | None = None,
+        sort: list[str] | None = None,
+    ) -> PageCustomFieldValueWithTcCountDto:
+        """List custom field values for a project field.
+
+        Args:
+            project_id: Target project ID.
+            custom_field_id: Target custom field ID (project-scoped).
+            query: Optional search query.
+            var_global: Optional global flag filter.
+            test_case_search: Optional test case search filter.
+            page: Zero-based page index.
+            size: Page size.
+            sort: Optional sort criteria.
+
+        Returns:
+            Paginated custom field values with test case counts.
+
+        Raises:
+            AllureNotFoundError: If project or custom field doesn't exist.
+            AllureValidationError: If input data fails validation.
+            AllureAuthError: If unauthorized.
+            AllureAPIError: If the server returns an error.
+        """
+        api = await self._get_api("_custom_field_value_project_api")
+
+        if not isinstance(project_id, int) or project_id <= 0:
+            raise AllureValidationError("Project ID must be a positive integer")
+        if not isinstance(custom_field_id, int) or custom_field_id == 0:
+            raise AllureValidationError("Custom Field ID must be a non-zero integer")
+        if page is not None and (not isinstance(page, int) or page < 0):
+            raise AllureValidationError("Page must be a non-negative integer")
+        if size is not None and (not isinstance(size, int) or size <= 0 or size > 1000):
+            raise AllureValidationError("Size must be between 1 and 1000")
+
+        return await self._call_api(
+            api.find_all22(
+                project_id=project_id,
+                custom_field_id=custom_field_id,
+                query=query,
+                var_global=var_global,
+                test_case_search=test_case_search,
+                page=page,
+                size=size,
+                sort=sort,
+                _request_timeout=self._timeout,
+            )
+        )
+
+    async def create_custom_field_value(
+        self, project_id: int, data: CustomFieldValueProjectCreateDto
+    ) -> CustomFieldValueWithCfDto:
+        """Create a custom field value in a project.
+
+        Args:
+            project_id: Target project ID.
+            data: Custom field value payload.
+
+        Returns:
+            The created custom field value DTO.
+
+        Raises:
+            AllureNotFoundError: If project doesn't exist.
+            AllureValidationError: If input data fails validation.
+            AllureAuthError: If unauthorized.
+            AllureAPIError: If the server returns an error.
+        """
+        api = await self._get_api("_custom_field_value_project_api")
+
+        if not isinstance(project_id, int) or project_id <= 0:
+            raise AllureValidationError("Project ID must be a positive integer")
+
+        try:
+            return await self._call_api(
+                api.create26(
+                    project_id=project_id,
+                    custom_field_value_project_create_dto=data,
+                    _request_timeout=self._timeout,
+                )
+            )
+        except AllureAPIError as exc:
+            if exc.status_code == 409:
+                raise AllureValidationError(
+                    "Duplicate custom field value name.",
+                    status_code=exc.status_code,
+                    response_body=exc.response_body,
+                    suggestions=["Use a unique custom field value name"],
+                ) from exc
+            raise
+
+    async def update_custom_field_value(
+        self, project_id: int, cfv_id: int, data: CustomFieldValueProjectPatchDto
+    ) -> None:
+        """Update a custom field value in a project.
+
+        Args:
+            project_id: Target project ID.
+            cfv_id: Target custom field value ID.
+            data: Patch payload for the custom field value.
+
+        Raises:
+            AllureNotFoundError: If project or value doesn't exist.
+            AllureValidationError: If input data fails validation.
+            AllureAuthError: If unauthorized.
+            AllureAPIError: If the server returns an error.
+        """
+        api = await self._get_api("_custom_field_value_project_api")
+
+        if not isinstance(project_id, int) or project_id <= 0:
+            raise AllureValidationError("Project ID must be a positive integer")
+        if not isinstance(cfv_id, int) or cfv_id <= 0:
+            raise AllureValidationError("Custom Field Value ID must be a positive integer")
+
+        await self._call_api(
+            api.patch23(
+                project_id=project_id,
+                cfv_id=cfv_id,
+                custom_field_value_project_patch_dto=data,
+                _request_timeout=self._timeout,
+            )
+        )
+
+    async def delete_custom_field_value(self, project_id: int, cfv_id: int) -> None:
+        """Delete a custom field value in a project.
+
+        Args:
+            project_id: Target project ID.
+            cfv_id: Target custom field value ID.
+
+        Raises:
+            AllureNotFoundError: If project or value doesn't exist.
+            AllureValidationError: If input data fails validation.
+            AllureAuthError: If unauthorized.
+            AllureAPIError: If the server returns an error.
+        """
+        api = await self._get_api("_custom_field_value_project_api")
+
+        if not isinstance(project_id, int) or project_id <= 0:
+            raise AllureValidationError("Project ID must be a positive integer")
+        if not isinstance(cfv_id, int) or cfv_id <= 0:
+            raise AllureValidationError("Custom Field Value ID must be a positive integer")
+
+        await self._call_api(
+            api.delete47(
+                project_id=project_id,
+                id=cfv_id,
+                _request_timeout=self._timeout,
+            )
+        )
+
     async def get_custom_fields_with_values(self, project_id: int) -> list[CustomFieldProjectWithValuesDto]:
         """Fetch all custom fields and their allowed values for a project.
 
@@ -923,6 +1373,49 @@ class AllureClient:
 
         return results
 
+    async def get_test_case_custom_fields(
+        self,
+        test_case_id: int,
+        project_id: int,
+    ) -> list[CustomFieldProjectWithValuesDto]:
+        """Fetch custom fields with values for a specific test case.
+
+        Args:
+            test_case_id: Target test case ID.
+            project_id: The project ID context.
+
+        Returns:
+            List of custom field DTOs with their assigned values.
+        """
+        api = await self._get_api("_test_case_custom_field_api")
+        return await self._call_api(
+            api.get_custom_fields_with_values3(
+                test_case_id=test_case_id,
+                project_id=project_id,
+                _request_timeout=self._timeout,
+            )
+        )
+
+    async def update_cfvs_of_test_case(
+        self,
+        test_case_id: int,
+        custom_fields: list[CustomFieldValueWithCfDto],
+    ) -> None:
+        """Update custom field values for a test case.
+
+        Args:
+            test_case_id: Target test case ID.
+            custom_fields: List of custom field DTOs with new values.
+        """
+        api = await self._get_api("_test_case_custom_field_api")
+        await self._call_api(
+            api.update_cfvs_of_test_case(
+                test_case_id=test_case_id,
+                custom_field_with_values_dto=custom_fields,
+                _request_timeout=self._timeout,
+            )
+        )
+
     async def delete_scenario_step(self, step_id: int) -> None:
         """Delete a scenario step.
 
@@ -933,14 +1426,14 @@ class AllureClient:
             AllureAPIError: If the API request fails.
         """
         scenario_api = await self._get_api("_scenario_api")
-        await self._call_api(
-            scenario_api.delete_by_id1(
+        await self._call_api_raw(
+            scenario_api.delete_by_id1_without_preload_content(
                 id=step_id,
                 _request_timeout=self._timeout,
             )
         )
 
-    async def get_test_case(self, test_case_id: int) -> TestCaseDto:
+    async def get_test_case(self, test_case_id: int) -> TestCaseDtoWithCF:
         """Retrieve a specific test case by its ID.
 
         Args:
@@ -973,6 +1466,8 @@ class AllureClient:
                 )
                 if overview.custom_fields:
                     case.custom_fields = overview.custom_fields
+                if overview.issues:
+                    case.issues = overview.issues
             except Exception as e:
                 logger.warning(f"Failed to fetch overview for test case {test_case_id}: {e}")
 
@@ -1041,7 +1536,6 @@ class AllureClient:
             )
         )
         raw_data = self._extract_response_data(response)
-        # print(f"DEBUG Initial Raw Normalized Scenario: {raw_data}")
         return self._denormalize_to_v2_from_dict(raw_data)
 
     @staticmethod
@@ -1114,13 +1608,14 @@ class AllureClient:
                     child_ids = step_def.get("children") or []
                     child_steps = build_steps(child_ids) if child_ids else None
 
-                    # Build BodyStepDtoWithSteps
+                    # Build StepWithExpected
                     steps_list.append(
                         SharedStepScenarioDtoStepsInner(
-                            actual_instance=BodyStepDtoWithSteps.model_construct(
+                            actual_instance=StepWithExpected.model_construct(
                                 type="BodyStepDto",
                                 body=body,
                                 body_json=None,  # Skip complex rich-text
+                                expected_result=step_def.get("expectedResult"),
                                 steps=child_steps,
                                 id=sid,
                             )
@@ -1219,6 +1714,38 @@ class AllureClient:
 
         return await self._create_scenario_step_via_api(shared_step_scenario_api, step)
 
+    async def patch_test_case_scenario_step(
+        self,
+        step_id: int,
+        patch: ScenarioStepPatchDto,
+    ) -> None:
+        """Patch a specific scenario step within a test case."""
+        scenario_api = await self._get_api("_scenario_api")
+        await self._call_api_raw(
+            scenario_api.patch_by_id_without_preload_content(
+                id=step_id,
+                scenario_step_patch_dto=patch,
+                with_expected_result=False,
+                _request_timeout=self._timeout,
+            )
+        )
+
+    async def patch_shared_step_scenario_step(
+        self,
+        step_id: int,
+        patch: ScenarioStepPatchDto,
+    ) -> None:
+        """Patch a specific scenario step within a shared step."""
+        shared_step_scenario_api = await self._get_api("_shared_step_scenario_api")
+        await self._call_api_raw(
+            shared_step_scenario_api.patch_by_id1_without_preload_content(
+                id=step_id,
+                scenario_step_patch_dto=patch,
+                with_expected_result=False,
+                _request_timeout=self._timeout,
+            )
+        )
+
     async def upload_shared_step_attachment(
         self,
         shared_step_id: int,
@@ -1306,3 +1833,21 @@ class AllureClient:
         shared_step_api = await self._get_api("_shared_step_api")
         # Soft delete via archive
         await self._call_api(shared_step_api.archive(id=shared_step_id, _request_timeout=self._timeout))
+
+    async def update_test_case_custom_fields(
+        self, test_case_id: int, custom_fields: list[CustomFieldValueWithCfDto]
+    ) -> None:
+        """Update custom field values of a test case using dedicated endpoint.
+
+        Args:
+            test_case_id: Target test case ID.
+            custom_fields: List of custom fields with values to set/clear.
+        """
+        api = await self._get_api("_test_case_custom_field_api")
+        await self._call_api(
+            api.update_cfvs_of_test_case(
+                test_case_id=test_case_id,
+                custom_field_with_values_dto=custom_fields,
+                _request_timeout=self._timeout,
+            )
+        )