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

src/services/shared_step_service.py

@@ -1,6 +1,6 @@
 import base64
 import logging
-from typing import Any
+from typing import cast
 
 from pydantic import ValidationError as PydanticValidationError
 
@@ -8,10 +8,11 @@ from src.client import (
     AllureClient,
     PageSharedStepDto,
     ScenarioStepCreateDto,
+    ScenarioStepPatchDto,
     SharedStepAttachmentRowDto,
     SharedStepDto,
 )
-from src.client.exceptions import AllureAPIError, AllureValidationError
+from src.client.exceptions import AllureAPIError, AllureNotFoundError, AllureValidationError
 from src.services.attachment_service import AttachmentService
 from src.utils.schema_hint import generate_schema_hint
 
@@ -37,7 +38,7 @@ class SharedStepService:
     async def create_shared_step(
         self,
         name: str,
-        steps: list[dict[str, Any]] | None = None,
+        steps: list[dict[str, object]] | None = None,
     ) -> SharedStepDto:
         """Create a new shared step with optional steps.
 
@@ -125,7 +126,12 @@ class SharedStepService:
             AllureNotFoundError: If shared step doesn't exist.
             AllureAPIError: If the server returns an error.
         """
-        return await self._client.get_shared_step(step_id)
+        try:
+            return await self._client.get_shared_step(step_id)
+        except (AllureNotFoundError, AllureValidationError, AllureAPIError):
+            raise
+        except Exception as e:
+            raise AllureAPIError(f"Failed to get shared step {step_id}: {e}") from e
 
     async def update_shared_step(
         self,
@@ -176,27 +182,31 @@ class SharedStepService:
         updated = await self._client.update_shared_step(step_id, patch_data)
         return updated, True
 
-    async def delete_shared_step(self, step_id: int) -> None:
+    async def delete_shared_step(self, step_id: int) -> bool:
         """Delete (archive) a shared step with idempotent behavior.
 
         Args:
             step_id: The shared step ID to delete.
 
+        Returns:
+            True if deleted, False if already deleted/not found.
+
         Raises:
             AllureAPIError: If the API request fails (other than 404).
 
         Note:
             This operation is idempotent following Story 1.5 pattern.
-            If already deleted (404), returns gracefully.
+            If already deleted (404), returns False.
         """
-        from src.client.exceptions import AllureNotFoundError
-
         try:
+            # Check existence first for accurate feedback
+            await self.get_shared_step(step_id)
             await self._client.delete_shared_step(step_id)
+            return True
         except AllureNotFoundError:
             # Idempotent: if already deleted, this is fine
             logger.debug(f"Shared step {step_id} already deleted or not found")
-            pass
+            return False
 
     # ==========================================
     # Helper Methods
@@ -205,7 +215,7 @@ class SharedStepService:
     async def _add_steps(
         self,
         shared_step_id: int,
-        steps: list[dict[str, Any]],
+        steps: list[dict[str, object]],
         parent_step_id: int | None = None,
     ) -> int | None:
         """Recursively add steps to a shared step."""
@@ -214,7 +224,7 @@ class SharedStepService:
         for s in steps:
             action = str(s.get("action", ""))
             expected = str(s.get("expected", ""))
-            step_attachments: list[dict[str, str]] = s.get("attachments", [])
+            step_attachments = cast(list[dict[str, str]], s.get("attachments", []))
 
             current_parent_id: int | None = parent_step_id
 
@@ -226,12 +236,19 @@ class SharedStepService:
                 response = await self._client.create_shared_step_scenario_step(step_dto)
                 current_parent_id = response.created_step_id
 
-                # 2. Expected Result (child of action)
-                if expected:
-                    expected_dto = self._build_scenario_step_dto(
-                        shared_step_id=shared_step_id, body=expected, parent_id=current_parent_id
+                # 2. Expected Result (patch action step)
+                if expected and current_parent_id is not None:
+                    await self._client.patch_shared_step_scenario_step(
+                        step_id=current_parent_id,
+                        patch=ScenarioStepPatchDto(body=action, expected_result=expected),
+                    )
+                    await self._client.create_shared_step_scenario_step(
+                        self._build_scenario_step_dto(
+                            shared_step_id=shared_step_id,
+                            body=expected,
+                            parent_id=current_parent_id,
+                        )
                     )
-                    await self._client.create_shared_step_scenario_step(expected_dto)
 
                 # 3. Attachments (children of action)
                 if step_attachments:
@@ -317,7 +334,7 @@ class SharedStepService:
         if len(name) > MAX_NAME_LENGTH:
             raise AllureValidationError(f"Name too long (max {MAX_NAME_LENGTH})")
 
-    def _validate_steps(self, steps: list[dict[str, Any]] | None) -> None:
+    def _validate_steps(self, steps: list[dict[str, object]] | None) -> None:
         if steps is None:
             return
         if not isinstance(steps, list):

src/services/test_case_service.py

@@ -1,4 +1,5 @@
 import logging
+import re
 from dataclasses import dataclass
 from typing import TypedDict, cast
 
@@ -7,7 +8,9 @@ from pydantic import ValidationError as PydanticValidationError
 from src.client import (
     AllureClient,
     AttachmentStepDtoWithName,
-    BodyStepDtoWithSteps,
+    ScenarioStepPatchDto,
+    StepWithExpected,
+    TestCaseDtoWithCF,
 )
 from src.client.exceptions import AllureAPIError, AllureNotFoundError, AllureValidationError
 from src.client.generated.models import (
@@ -15,11 +18,14 @@ from src.client.generated.models import (
     CustomFieldValueDto,
     CustomFieldValueWithCfDto,
     ExternalLinkDto,
+    IssueDto,
     ScenarioStepCreateDto,
     SharedStepScenarioDtoStepsInner,
+    TestCaseBulkIssueDto,
     TestCaseCreateV2Dto,
     TestCaseDto,
     TestCaseOverviewDto,
+    TestCaseTreeSelectionDto,
     TestLayerDto,
     TestTagDto,
 )
@@ -72,8 +78,14 @@ class TestCaseUpdate:
     expected_result: str | None = None
     status_id: int | None = None
     test_layer_id: int | None = None
+    test_layer_name: str | None = None
     workflow_id: int | None = None
     links: list[dict[str, str]] | None = None
+    issues: list[str] | None = None
+    remove_issues: list[str] | None = None
+    clear_issues: bool | None = None
+    integration_id: int | None = None
+    integration_name: str | None = None
 
 
 @dataclass
@@ -112,6 +124,9 @@ class TestCaseService:
         custom_fields: dict[str, str | list[str]] | None = None,
         test_layer_id: int | None = None,
         test_layer_name: str | None = None,
+        issues: list[str] | None = None,
+        integration_id: int | None = None,
+        integration_name: str | None = None,
     ) -> TestCaseOverviewDto:
         """Create a new test case.
 
@@ -124,6 +139,9 @@ class TestCaseService:
             custom_fields: Optional dictionary of custom fields (Name -> Value).
             test_layer_id: Optional test layer ID to assign to the test case.
             test_layer_name: Optional test layer name to assign to the test case.
+            issues: Optional list of issue keys to link (e.g., 'PROJ-123').
+            integration_id: Optional integration ID for issue linking (required when multiple exist).
+            integration_name: Optional integration name for issue linking (mutually exclusive with integration_id).
 
         Returns:
             The created test case overview.
@@ -232,6 +250,15 @@ class TestCaseService:
 
             # Add global attachments (appended at end of steps)
             await self._add_global_attachments(test_case_id, attachments, last_step_id)
+
+            # Add issue links
+            if issues:
+                await self.add_issues_to_test_case(
+                    test_case_id,
+                    issues,
+                    integration_id=integration_id,
+                    integration_name=integration_name,
+                )
         except Exception as e:
             # Rollback: delete the partially created test case
             try:
@@ -248,7 +275,7 @@ class TestCaseService:
 
         return created_test_case
 
-    async def get_test_case(self, test_case_id: int) -> TestCaseDto:
+    async def get_test_case(self, test_case_id: int) -> TestCaseDtoWithCF:
         """Retrieve a test case by ID.
 
         Args:
@@ -345,6 +372,9 @@ class TestCaseService:
                 data.test_layer_id is not None,
                 data.workflow_id is not None,
                 data.links is not None,
+                data.issues is not None,
+                data.remove_issues is not None,
+                data.clear_issues is not None,
             ]
         )
         has_scenario_changes = data.steps is not None or data.attachments is not None
@@ -358,16 +388,54 @@ class TestCaseService:
             updated_case = await self.get_test_case(test_case_id)
             return updated_case if updated_case is not None else current_case
 
-        if data.test_layer_id is not None:
-            self._validate_test_layer_id(data.test_layer_id)
-            current_test_layer_id = current_case.test_layer.id if current_case.test_layer else None
-            if data.test_layer_id != current_test_layer_id:
-                await self._validate_test_layer_exists(data.test_layer_id, project_id)
+        if data.clear_issues:
+            # Use current_case fetched at step 1 instead of re-fetching
+            if current_case and current_case.issues:
+                existing_keys = [i.name for i in current_case.issues if i.name]
+                if existing_keys:
+                    await self.remove_issues_from_test_case(test_case_id, existing_keys)
+
+        if data.remove_issues:
+            await self.remove_issues_from_test_case(test_case_id, data.remove_issues)
+
+        if data.issues:
+            await self.add_issues_to_test_case(
+                test_case_id,
+                data.issues,
+                integration_id=data.integration_id,
+                integration_name=data.integration_name,
+            )
 
-        # 3. Handle Metadata Patches
+        # 4. Handle Metadata Patches
         patch_kwargs, has_changes = await self._prepare_field_updates(current_case, data)
 
-        # 4. Handle Custom Fields in mixed update (replacement)
+        if data.test_layer_id is not None or data.test_layer_name is not None:
+            current_test_layer_id = current_case.test_layer.id if current_case.test_layer else None
+            resolved_layer_id = None
+            skip_validation = False
+
+            if data.test_layer_id is not None and data.test_layer_name is None:
+                if data.test_layer_id == current_test_layer_id:
+                    skip_validation = True
+                    resolved_layer_id = data.test_layer_id
+
+            if not skip_validation:
+                # Resolve the ID using the validation helper
+                # Note: _validate_test_layer handles mutual exclusivity check
+                resolved_layer_id = await self._validate_test_layer(
+                    test_layer_id=data.test_layer_id,
+                    test_layer_name=data.test_layer_name,
+                )
+
+            current_test_layer_id = current_case.test_layer.id if current_case.test_layer else None
+
+            # Only update if the resolved ID is different (and not None)
+            if resolved_layer_id is not None and resolved_layer_id != current_test_layer_id:
+                # Add to patch_kwargs which is now initialized
+                patch_kwargs["test_layer_id"] = resolved_layer_id
+                has_changes = True
+
+        # 5. Handle Custom Fields in mixed update (replacement)
         if data.custom_fields is not None:
             # For mixed updates via patch13, we need to provide the FULL list of custom fields
             # since the API replaces them. We merge current + updates.
@@ -422,7 +490,7 @@ class TestCaseService:
                 patch_kwargs["customFields"] = final_cfs
                 has_changes = True
 
-        # 5. Handle Scenario
+        # 6. Handle Scenario
         scenario_dto_v2 = await self._prepare_scenario_update(test_case_id, data)
         if scenario_dto_v2:
             has_changes = True
@@ -430,7 +498,7 @@ class TestCaseService:
         if not has_changes:
             return current_case
 
-        # 6. Apply Update
+        # 7. Apply Update
         try:
             patch_data = TestCasePatchV2Dto(**patch_kwargs)
             await self._client.update_test_case(test_case_id, patch_data)
@@ -438,7 +506,7 @@ class TestCaseService:
             hint = generate_schema_hint(TestCasePatchV2Dto)
             raise AllureValidationError(f"Invalid update data: {e}", suggestions=[hint]) from e
 
-        # 7. Apply Scenario Re-creation
+        # 8. Apply Scenario Re-creation
         if scenario_dto_v2 and scenario_dto_v2.steps is not None:
             await self._recreate_scenario(test_case_id, scenario_dto_v2.steps)
 
@@ -572,6 +640,139 @@ class TestCaseService:
 
         return await self.get_test_case(test_case_id)
 
+    async def add_issues_to_test_case(
+        self,
+        test_case_id: int,
+        issues: list[str],
+        integration_id: int | None = None,
+        integration_name: str | None = None,
+    ) -> None:
+        """Add issue links to a test case.
+
+        Args:
+            test_case_id: The test case ID.
+            issues: List of issue keys (e.g. "PROJ-123").
+            integration_id: Optional integration ID (required when multiple exist).
+            integration_name: Optional integration name (mutually exclusive with integration_id).
+        """
+        if not issues:
+            return
+
+        # 1. Resolve integrations and build IssueDtos
+        issue_dtos = await self._build_issue_dtos(
+            issues,
+            integration_id=integration_id,
+            integration_name=integration_name,
+        )
+
+        # Idempotency Filter: Only link issues not already present
+        current_case = await self.get_test_case(test_case_id)
+        existing_names = {i.name.upper() for i in (current_case.issues or []) if i.name}
+        issue_dtos = [io for io in issue_dtos if io.name not in existing_names]
+
+        if not issue_dtos:
+            return
+
+        # 2. Build selection
+        selection = TestCaseTreeSelectionDto(project_id=self._project_id, leafs_include=[test_case_id])
+
+        # 3. Call Bulk API
+        from src.client.generated.api.test_case_bulk_controller_api import TestCaseBulkControllerApi
+
+        bulk_api = TestCaseBulkControllerApi(self._client.api_client)
+
+        bulk_dto = TestCaseBulkIssueDto(issues=issue_dtos, selection=selection)
+        await bulk_api.issue_add1(bulk_dto)
+
+    async def remove_issues_from_test_case(self, test_case_id: int, issues: list[str]) -> None:
+        """Remove issue links from a test case.
+
+        Args:
+            test_case_id: The test case ID.
+            issues: List of issue keys to remove.
+        """
+        if not issues:
+            return
+
+        # 1. Fetch current issues to get their IDs
+        current_case = await self.get_test_case(test_case_id)
+        if not current_case.issues:
+            return
+
+        # 2. Find IDs of issues to remove
+        issues_to_remove_ids = []
+        issues_set = set(issues)
+
+        for issue in current_case.issues:
+            if issue.name and issue.name in issues_set and issue.id:
+                issues_to_remove_ids.append(issue.id)
+
+        if not issues_to_remove_ids:
+            return
+
+        # 3. Call Bulk API with IDs
+        selection = TestCaseTreeSelectionDto(project_id=self._project_id, leafs_include=[test_case_id])
+
+        from src.client.generated.api.test_case_bulk_controller_api import TestCaseBulkControllerApi
+        from src.client.generated.models.test_case_bulk_entity_ids_dto import TestCaseBulkEntityIdsDto
+
+        bulk_api = TestCaseBulkControllerApi(self._client.api_client)
+
+        bulk_dto = TestCaseBulkEntityIdsDto(ids=issues_to_remove_ids, selection=selection)
+        await bulk_api.issue_remove1(bulk_dto)
+
+    MAX_ISSUE_KEY_LENGTH = 50
+    ISSUE_KEY_PATTERN = re.compile(r"^[A-Z0-9]+-\d+$", re.IGNORECASE)
+
+    async def _build_issue_dtos(
+        self,
+        issues: list[str],
+        integration_id: int | None = None,
+        integration_name: str | None = None,
+    ) -> list[IssueDto]:
+        """Convert issue keys to IssueDto objects with resolved integration IDs.
+
+        Validation:
+        - Checks issue key format (e.g., PROJ-123).
+        - Resolves integration ID using IntegrationService.
+        - AC#6: Auto-selects when only one integration exists.
+        - AC#7: Errors when multiple integrations exist and none specified.
+        """
+        if not issues:
+            return []
+
+        # 1. Validate Issue Keys
+        invalid_keys = []
+        for key in issues:
+            if not key or len(key) > self.MAX_ISSUE_KEY_LENGTH:
+                invalid_keys.append(f"{key} (too long)")
+            elif not self.ISSUE_KEY_PATTERN.match(key):
+                invalid_keys.append(f"{key} (invalid format, expected PROJECT-123)")
+
+        if invalid_keys:
+            raise AllureValidationError(
+                "Invalid issue keys provided:\n"
+                + "\n".join(f"- {k}" for k in invalid_keys)
+                + "\n\nHint: Issue keys must follow the format 'PROJECT-123' (alphanumeric prefix, hyphen, number)."
+            )
+
+        # 2. Resolve Integration using IntegrationService
+        from src.services.integration_service import IntegrationService
+
+        integration_service = IntegrationService(self._client)
+        target_integration_id = await integration_service.resolve_integration_for_issues(
+            integration_id=integration_id,
+            integration_name=integration_name,
+        )
+
+        # 3. Build DTOs
+        dtos = []
+        for key in issues:
+            dto = IssueDto(name=key.upper(), integration_id=target_integration_id)  # Normalize to uppercase
+            dtos.append(dto)
+
+        return dtos
+
     async def _prepare_field_updates(  # noqa: C901
         self, current_case: TestCaseDto, data: TestCaseUpdate
     ) -> tuple[dict[str, object], bool]:
@@ -605,11 +806,8 @@ class TestCaseService:
                 patch_kwargs["status_id"] = data.status_id
                 has_changes = True
 
-        if data.test_layer_id is not None:
-            current_test_layer_id = current_case.test_layer.id if current_case.test_layer else None
-            if data.test_layer_id != current_test_layer_id:
-                patch_kwargs["test_layer_id"] = data.test_layer_id
-                has_changes = True
+        # test_layer_id is handled centrally in update_test_case logic due to name resolution complexity
+        # and validation requirements. We skip it here to avoid duplication.
 
         if data.workflow_id is not None:
             current_workflow_id = current_case.workflow.id if current_case.workflow else None
@@ -721,13 +919,6 @@ class TestCaseService:
 
             children: list[SharedStepScenarioDtoStepsInner] = []
 
-            if expected:
-                children.append(
-                    SharedStepScenarioDtoStepsInner(
-                        actual_instance=ExpectedBodyStepDto(type="ExpectedBodyStepDto", body=expected)
-                    )
-                )
-
             if step_attachments and isinstance(step_attachments, list):
                 for sa in step_attachments:
                     if isinstance(sa, dict):
@@ -748,7 +939,12 @@ class TestCaseService:
 
             dtos.append(
                 SharedStepScenarioDtoStepsInner(
-                    actual_instance=BodyStepDtoWithSteps(type="BodyStepDto", body=action, steps=children)
+                    actual_instance=StepWithExpected(
+                        type="BodyStepDto",
+                        body=action,
+                        expected_result=expected or None,
+                        steps=children,
+                    )
                 )
             )
         return dtos
@@ -892,8 +1088,8 @@ class TestCaseService:
         """Validate test layer ID format."""
         if test_layer_id is None:
             return
-        if not isinstance(test_layer_id, int) or test_layer_id <= 0:
-            raise AllureValidationError("Test layer ID must be a positive integer")
+        if not isinstance(test_layer_id, int) or test_layer_id < 0:
+            raise AllureValidationError("Test layer ID must be a positive integer or 0 (to unset)")
 
     def _format_available_layers(self, layers: list[TestLayerDto]) -> str:
         display_lines: list[str] = []
@@ -940,6 +1136,9 @@ class TestCaseService:
 
         if test_layer_id is not None:
             self._validate_test_layer_id(test_layer_id)
+            if test_layer_id == 0:
+                return 0
+
             try:
                 await self._test_layer_service.get_test_layer(test_layer_id)
             except AllureNotFoundError as e:
@@ -1019,7 +1218,15 @@ class TestCaseService:
         """Get or fetch custom field name-to-info mapping for a project."""
         if project_id in self._cf_cache:
             return self._cf_cache[project_id]
+        return await self._fetch_resolved_custom_fields(project_id)
 
+    async def refresh_resolved_custom_fields(self, project_id: int) -> dict[str, ResolvedCustomFieldInfo]:
+        """Refresh cached custom field name-to-info mapping for a project."""
+        if project_id in self._cf_cache:
+            del self._cf_cache[project_id]
+        return await self._fetch_resolved_custom_fields(project_id)
+
+    async def _fetch_resolved_custom_fields(self, project_id: int) -> dict[str, ResolvedCustomFieldInfo]:
         # Use the client wrapper method for consistent error handling and response processing
         cfs = await self._client.get_custom_fields_with_values(project_id)
         logger.debug("Fetched %d custom fields for project %d", len(cfs), project_id)
@@ -1277,19 +1484,21 @@ class TestCaseService:
                 current_parent_id = response.created_step_id
                 last_step_id = current_parent_id
 
-                # If there's an expected result, create it as a child step under the action
-                if expected:
-                    expected_step_dto = self._build_scenario_step_dto(
-                        test_case_id=test_case_id,
-                        body=expected,
-                        parent_id=current_parent_id,
+                # If there's an expected result, patch the action step
+                if expected and current_parent_id is not None:
+                    await self._client.patch_test_case_scenario_step(
+                        step_id=current_parent_id,
+                        patch=ScenarioStepPatchDto(body=action, expected_result=expected),
                     )
-                    expected_response = await self._client.create_scenario_step(
+                    await self._client.create_scenario_step(
                         test_case_id=test_case_id,
-                        step=expected_step_dto,
-                        after_id=None,  # First child
+                        step=self._build_scenario_step_dto(
+                            test_case_id=test_case_id,
+                            body=expected,
+                            parent_id=current_parent_id,
+                        ),
+                        after_id=None,
                     )
-                    last_child_id = expected_response.created_step_id
 
                 # Step Attachments (added as children of the action step)
                 if step_attachments and isinstance(step_attachments, list):
@@ -1376,6 +1585,22 @@ class TestCaseService:
             resp = await self._client.create_scenario_step(test_case_id=test_case_id, step=step_dto, after_id=after_id)
             created_id = resp.created_step_id
 
+            expected_result = getattr(instance, "expected_result", None)
+            if expected_result and created_id is not None:
+                await self._client.patch_test_case_scenario_step(
+                    step_id=created_id,
+                    patch=ScenarioStepPatchDto(body=instance.body, expected_result=expected_result),
+                )
+                await self._client.create_scenario_step(
+                    test_case_id=test_case_id,
+                    step=self._build_scenario_step_dto(
+                        test_case_id=test_case_id,
+                        body=expected_result,
+                        parent_id=created_id,
+                    ),
+                    after_id=None,
+                )
+
             # Add children (steps may not be a defined field in generated DTO,
             # but we set it via model_construct)
             child_steps = getattr(instance, "steps", None)
@@ -1398,6 +1623,13 @@ class TestCaseService:
             resp = await self._client.create_scenario_step(test_case_id=test_case_id, step=step_dto, after_id=after_id)
             created_id = resp.created_step_id
 
+        elif isinstance(instance, SharedStepStepDto):
+            step_dto = self._build_scenario_step_dto(
+                test_case_id=test_case_id, shared_step_id=instance.shared_step_id, parent_id=parent_id
+            )
+            resp = await self._client.create_scenario_step(test_case_id=test_case_id, step=step_dto, after_id=after_id)
+            created_id = resp.created_step_id
+
         return created_id if created_id else after_id
 
     async def _add_global_attachments(

src/services/test_layer_service.py

@@ -123,6 +123,8 @@ class TestLayerService:
         except ApiException as e:
             self._client._handle_api_exception(e)
             raise
+        except (AllureNotFoundError, AllureValidationError, AllureAPIError):
+            raise
         except Exception as e:
             raise AllureAPIError(f"Failed to get test layer {layer_id}: {e}") from e
 
@@ -192,6 +194,8 @@ class TestLayerService:
             raise AllureAPIError("Test Layer API is not initialized")
 
         try:
+            # Check existence first for accurate feedback
+            await self.get_test_layer(layer_id)
             await self._client._test_layer_api.delete9(id=layer_id)
             return True
         except AllureNotFoundError:
@@ -300,6 +304,11 @@ class TestLayerService:
 
         try:
             return await self._client._test_layer_schema_api.find_one7(id=schema_id)
+        except ApiException as e:
+            self._client._handle_api_exception(e)
+            raise
+        except (AllureNotFoundError, AllureValidationError, AllureAPIError):
+            raise
         except Exception as e:
             raise AllureAPIError(f"Failed to get test layer schema {schema_id}: {e}") from e
 
@@ -385,6 +394,8 @@ class TestLayerService:
             raise AllureAPIError("Test Layer Schema API is not initialized")
 
         try:
+            # Check existence first for accurate feedback
+            await self.get_test_layer_schema(schema_id)
             await self._client._test_layer_schema_api.delete8(id=schema_id)
             return True
         except AllureNotFoundError: