test(tools_integrations): pin negative paths of 404-narrow + Path 4 non-not_found

Three new unit tests defend the idempotent contract's narrow against
future regression:

1. test_simple_path_404_on_state_check_routes_to_already_deleted —
   pins the positive case of the Path 1 fallback-2 fix from 781e083:
   get_entity_state raises HomeAssistantAPIError(status_code=404) →
   classified as state_gone → registry-verify confirms absent →
   idempotent already_deleted return. Without this test, a future
   refactor that removes the 404 branch could silently break the
   never-existed-target idempotent contract.

2. test_simple_path_non_404_apierror_propagates — pins the negative
   case of the same narrow: HomeAssistantAPIError(status_code=500)
   on the state-check must propagate via the outer exception chain,
   NOT silently classify as state_gone. Defends against a regression
   that drops the ``if e.status_code != 404: raise`` guard.

3. test_remove_helpers_integrations_subentry_other_error_surfaces_service_call_failed —
   pins the Path 4 negative case: an HA error response with a code
   other than "not_found" (e.g. "permission_denied") must raise
   SERVICE_CALL_FAILED with the original error message preserved,
   not idempotent-succeed. Symmetric counterpart to
   test_remove_helpers_integrations_subentry_not_found_is_idempotent
   which pins the positive (idempotent) case.

74 unit tests pass across test_tools_integrations.py (52) and
test_config_subentries_folded.py (22).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: Patch76

tests/src/unit/test_config_subentries_folded.py

@@ -526,3 +526,32 @@ async def test_remove_helpers_integrations_subentry_not_found_is_idempotent(
     assert result["fallback_used"] == "already_deleted"
     assert result["subentry_id"] == "ghost-subentry"
     assert result["method"] == "config_subentry_delete"
+
+
+async def test_remove_helpers_integrations_subentry_other_error_surfaces_service_call_failed(
+    mock_client,
+):
+    """Path 4 negative case: a non-not_found error code (e.g. HA returns
+    a permission, validation, or unknown-error code) must NOT silently
+    classify as idempotent success. SERVICE_CALL_FAILED is the expected
+    surface, with the underlying error message preserved.
+    """
+    mock_client.delete_config_subentry.return_value = {
+        "success": False,
+        "error": {
+            "code": "permission_denied",
+            "message": "Insufficient permissions to delete subentry",
+        },
+    }
+
+    with pytest.raises(ToolError) as exc_info:
+        await IntegrationTools(mock_client).ha_remove_helpers_integrations(
+            target="entry-1",
+            helper_type="config_subentry",
+            subentry_id="subentry-1",
+            confirm=True,
+        )
+
+    error_data = json.loads(str(exc_info.value))
+    assert error_data["error"]["code"] == "SERVICE_CALL_FAILED"
+    assert "Insufficient permissions" in error_data["error"]["message"]

tests/src/unit/test_tools_integrations.py

@@ -328,6 +328,73 @@ async def test_simple_path_fallback_already_deleted(self, tools, mock_client):
         assert result["success"] is True
         assert result["fallback_used"] == "already_deleted"
 
+    async def test_simple_path_404_on_state_check_routes_to_already_deleted(
+        self, tools, mock_client
+    ):
+        """Pin the Path 1 fallback-2 contract for never-existed targets:
+        get_entity_state raising HomeAssistantAPIError(status_code=404)
+        must classify as state_gone → registry-verify confirms absent →
+        idempotent already_deleted return. Without the 404 catch in
+        fallback-2 a never-existed target falls through to ENTITY_NOT_FOUND.
+        """
+        # 3x registry retries return success=False → no unique_id
+        # 1x direct-id delete returns success=False → falls through to
+        #   fallback-2
+        # 1x verify-registry returns success=False → registry confirms absent
+        mock_client.send_websocket_message.side_effect = (
+            [{"success": False, "error": "Entity not found"}] * 3
+            + [{"success": False, "error": "Unable to find input_button_id"}]
+            + [{"success": False, "error": "Entity not found"}]
+        )
+        # State check raises 404 throughout — never-existed entity case
+        mock_client.get_entity_state.side_effect = HomeAssistantAPIError(
+            "Entity not found", status_code=404
+        )
+
+        result = await tools.ha_remove_helpers_integrations(
+            target="never_existed_button",
+            helper_type="input_button",
+            confirm=True,
+            wait=False,
+        )
+        assert result["success"] is True
+        assert result["fallback_used"] == "already_deleted"
+
+    async def test_simple_path_non_404_apierror_propagates(
+        self, tools, mock_client
+    ):
+        """Pin the Path 1 narrow: only status_code == 404 classifies as
+        state_gone. Other APIError status codes (e.g. 500 server error,
+        401 auth failure) must propagate via the outer exception chain
+        rather than silently mis-classify as idempotent success.
+        """
+        # 3x registry retries return success=False → no unique_id
+        # 1x direct-id delete returns success=False → falls through
+        mock_client.send_websocket_message.side_effect = (
+            [{"success": False, "error": "Entity not found"}] * 3
+            + [{"success": False, "error": "Unable to find"}]
+        )
+        # State check raises a non-404 APIError — must propagate
+        mock_client.get_entity_state.side_effect = HomeAssistantAPIError(
+            "Internal server error", status_code=500
+        )
+
+        with pytest.raises(ToolError) as exc_info:
+            await tools.ha_remove_helpers_integrations(
+                target="server_error_button",
+                helper_type="input_button",
+                confirm=True,
+                wait=False,
+            )
+        err = json.loads(str(exc_info.value))
+        assert err["success"] is False
+        # Outer chain converts the propagated APIError via
+        # exception_to_structured_error — must NOT be classified as
+        # already_deleted.
+        assert err["error"]["code"] != "ENTITY_NOT_FOUND" or (
+            "already_deleted" not in err.get("error", {}).get("message", "")
+        )
+
     async def test_simple_path_disabled_no_unique_id_surfaces_error(
         self, tools, mock_client
     ):