test(workspace): add behavioral tests for broadcast_message and _upload_chat_files

Adds 25 new behavioral tests to test_a2a_tools_messaging.py targeting
the uncovered paths in a2a_tools_messaging.py (9% → 54% coverage).

Coverage gaps addressed (issue #1156):
- tool_broadcast_message: empty-message, 200/success, 403/disabled,
  non-2xx error, connection error
- _upload_chat_files: empty paths, invalid path type, missing file,
  OSError on read, connection failure, non-200, invalid JSON,
  missing files key, count mismatch, success with metadata,
  mime-type guessing from extension, unknown-extension fallback
- tool_send_message_to_user: 403/talk_to_user_disabled with hint,
  without hint, malformed JSON response

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

workspace/tests/test_a2a_tools_messaging.py

@@ -15,10 +15,15 @@ This file pins:
      ``a2a_tools`` at module-load time (the layered architecture: it
      depends on ``a2a_tools_rbac`` + ``a2a_client`` + ``platform_auth``,
      never the kitchen-sink module).
+  3. **Behavioral tests** — tool_broadcast_message, _upload_chat_files,
+     and tool_send_message_to_user error paths not covered by the
+     impl-level test suite.
 """
 from __future__ import annotations
 
+import json
 import sys
+from unittest.mock import AsyncMock, patch
 
 import pytest
 
@@ -90,3 +95,328 @@ class TestImportContract:
         assert hasattr(a2a_tools, "tool_get_workspace_info")
         assert hasattr(a2a_tools, "tool_chat_history")
         assert hasattr(a2a_tools, "_upload_chat_files")
+
+
+# ---------------------------------------------------------------------------
+# Helpers shared by behavioral tests below
+# ---------------------------------------------------------------------------
+
+def _make_mock_client(*, post_resp=None, post_exc=None):
+    """Return a mock AsyncClient that behaves as an async context manager."""
+    mc = AsyncMock()
+    mc.__aenter__ = AsyncMock(return_value=mc)
+    mc.__aexit__ = AsyncMock(return_value=False)
+    if post_exc is not None:
+        mc.post = AsyncMock(side_effect=post_exc)
+    else:
+        mc.post = AsyncMock(return_value=post_resp)
+    return mc
+
+
+def _resp(status_code, payload):
+    """Build a fake httpx.Response with the given status and JSON body."""
+    response = AsyncMock()
+    response.status_code = status_code
+    response.json = lambda: payload
+    response.text = json.dumps(payload)
+    return response
+
+
+# ---------------------------------------------------------------------------
+# tool_broadcast_message — behavioral tests (not covered by test_a2a_tools_impl)
+# ---------------------------------------------------------------------------
+
+class TestToolBroadcastMessage:
+
+    async def test_empty_message_returns_error(self):
+        """Empty string returns an error without any HTTP call."""
+        import a2a_tools_messaging
+        result = await a2a_tools_messaging.tool_broadcast_message("")
+        assert "Error" in result
+        assert "required" in result
+
+    async def test_success_200_returns_delivered_count(self):
+        """200 with delivered count returns the count."""
+        import a2a_tools_messaging
+        mc = _make_mock_client(post_resp=_resp(200, {"delivered": 3}))
+        with patch("a2a_tools_messaging.httpx.AsyncClient", return_value=mc):
+            result = await a2a_tools_messaging.tool_broadcast_message("All hands meeting at 3pm")
+        assert "3" in result
+        assert "workspace" in result
+
+    async def test_success_200_missing_delivered_key_defaults_to_zero(self):
+        """200 with no delivered key doesn't crash — formats as '?'."""
+        import a2a_tools_messaging
+        mc = _make_mock_client(post_resp=_resp(200, {}))
+        with patch("a2a_tools_messaging.httpx.AsyncClient", return_value=mc):
+            result = await a2a_tools_messaging.tool_broadcast_message("ping")
+        assert "?" in result
+
+    async def test_403_returns_broadcast_disabled_error(self):
+        """403 with hint returns the hint text."""
+        import a2a_tools_messaging
+        mc = _make_mock_client(post_resp=_resp(403, {"hint": "Enable broadcast in workspace settings."}))
+        with patch("a2a_tools_messaging.httpx.AsyncClient", return_value=mc):
+            result = await a2a_tools_messaging.tool_broadcast_message("Alert!")
+        assert "403" not in result  # error class handles 403 specially
+        assert "not enabled" in result.lower()
+        assert "Enable broadcast" in result
+
+    async def test_403_without_hint_returns_generic_disabled_message(self):
+        """403 without a hint returns a generic disabled message."""
+        import a2a_tools_messaging
+        mc = _make_mock_client(post_resp=_resp(403, {}))
+        with patch("a2a_tools_messaging.httpx.AsyncClient", return_value=mc):
+            result = await a2a_tools_messaging.tool_broadcast_message("Alert!")
+        assert "not enabled" in result.lower()
+
+    async def test_403_malformed_json_returns_disabled_without_hint(self):
+        """403 where .json() raises still returns the disabled message."""
+        import a2a_tools_messaging
+        response = _resp(403, {})
+        response.json = lambda: (_ for _ in ()).throw(ValueError("boom"))
+        mc = _make_mock_client(post_resp=response)
+        with patch("a2a_tools_messaging.httpx.AsyncClient", return_value=mc):
+            result = await a2a_tools_messaging.tool_broadcast_message("Alert!")
+        assert "not enabled" in result.lower()
+
+    async def test_non_200_non_403_returns_status_code_error(self):
+        """Any other non-2xx status returns a generic error with the code."""
+        import a2a_tools_messaging
+        mc = _make_mock_client(post_resp=_resp(500, {"error": "internal error"}))
+        with patch("a2a_tools_messaging.httpx.AsyncClient", return_value=mc):
+            result = await a2a_tools_messaging.tool_broadcast_message("Alert!")
+        assert "500" in result
+        assert "Error" in result
+
+    async def test_connection_error_returns_error_with_exception_message(self):
+        """Network failure returns the exception text."""
+        import a2a_tools_messaging
+        mc = _make_mock_client(post_exc=ConnectionError("connection refused"))
+        with patch("a2a_tools_messaging.httpx.AsyncClient", return_value=mc):
+            result = await a2a_tools_messaging.tool_broadcast_message("Alert!")
+        assert "Error sending broadcast" in result
+        assert "connection refused" in result
+
+
+# ---------------------------------------------------------------------------
+# _upload_chat_files — behavioral tests
+# ---------------------------------------------------------------------------
+
+class TestUploadChatFiles:
+    """Tests for the internal _upload_chat_files helper (lines 39-101)."""
+
+    async def test_empty_paths_returns_empty_and_none(self):
+        """Empty list returns ([], None) — no HTTP call."""
+        import a2a_tools_messaging
+        mc = _make_mock_client()
+        result = await a2a_tools_messaging._upload_chat_files(mc, [])
+        assert result == ([], None)
+
+    async def test_invalid_path_type_returns_error(self):
+        """Non-string path type returns an error without HTTP call."""
+        import a2a_tools_messaging
+        mc = _make_mock_client()
+        result = await a2a_tools_messaging._upload_chat_files(mc, [None])
+        assert result[1] is not None
+        assert "invalid" in result[1].lower()
+
+    async def test_empty_string_path_returns_error(self):
+        """Empty-string path returns an error without HTTP call."""
+        import a2a_tools_messaging
+        mc = _make_mock_client()
+        result = await a2a_tools_messaging._upload_chat_files(mc, [""])
+        assert result[1] is not None
+        assert "invalid" in result[1].lower()
+
+    async def test_nonexistent_path_returns_not_found_error(self):
+        """Path that doesn't exist on disk returns an error without HTTP call."""
+        import a2a_tools_messaging
+        mc = _make_mock_client()
+        result = await a2a_tools_messaging._upload_chat_files(
+            mc, ["/no/such/file/anywhere.txt"],
+        )
+        assert result[1] is not None
+        assert "not found" in result[1].lower()
+
+    async def test_read_error_returns_read_error_message(self, tmp_path):
+        """OSError on file read returns the OS error text."""
+        import a2a_tools_messaging
+        mc = _make_mock_client()
+
+        # Create a file, then remove its parent to trigger OSError on open.
+        f = tmp_path / "gone.txt"
+        f.write_text("stub")
+        f.chmod(0o000)  # remove read permission — OSError on open
+
+        try:
+            result = await a2a_tools_messaging._upload_chat_files(mc, [str(f)])
+            assert result[1] is not None
+            assert "Error reading" in result[1]
+        finally:
+            # Restore permissions so the temp dir cleanup can delete the file.
+            f.chmod(0o644)
+
+    async def test_upload_connection_error_returns_error(self, tmp_path):
+        """Connection failure returns the exception text."""
+        import a2a_tools_messaging
+        mc = _make_mock_client(post_exc=OSError("no such host"))
+        f = tmp_path / "f.txt"
+        f.write_text("content")
+        result = await a2a_tools_messaging._upload_chat_files(mc, [str(f)])
+        assert result[1] is not None
+        assert "Error uploading attachments" in result[1]
+        assert "no such host" in result[1]
+
+    async def test_upload_non_200_returns_status_code_error(self, tmp_path):
+        """Non-200 upload response returns error with status code."""
+        import a2a_tools_messaging
+        mc = _make_mock_client(post_resp=_resp(502, {"error": "bad gateway"}))
+        f = tmp_path / "f.txt"
+        f.write_text("content")
+        result = await a2a_tools_messaging._upload_chat_files(mc, [str(f)])
+        assert result[1] is not None
+        assert "502" in result[1]
+
+    async def test_upload_invalid_json_returns_parse_error(self, tmp_path):
+        """Non-JSON response returns a parse error."""
+        import a2a_tools_messaging
+        response = _resp(200, {})
+        response.json = lambda: (_ for _ in ()).throw(ValueError("not json"))
+        response.text = "not json at all"
+        mc = _make_mock_client(post_resp=response)
+        f = tmp_path / "f.txt"
+        f.write_text("content")
+        result = await a2a_tools_messaging._upload_chat_files(mc, [str(f)])
+        assert result[1] is not None
+        assert "Error parsing upload response" in result[1]
+
+    async def test_upload_missing_files_key_returns_invalid_error(self, tmp_path):
+        """200 with no 'files' key returns an error."""
+        import a2a_tools_messaging
+        mc = _make_mock_client(post_resp=_resp(200, {}))
+        f = tmp_path / "f.txt"
+        f.write_text("content")
+        result = await a2a_tools_messaging._upload_chat_files(mc, [str(f)])
+        assert result[1] is not None
+        # Code path: body.get("files") returns [] (key absent), 0 != 1 → error.
+        assert "0" in result[1] and "1" in result[1]
+
+    async def test_upload_file_count_mismatch_returns_error(self, tmp_path):
+        """200 with wrong number of returned files returns an error."""
+        import a2a_tools_messaging
+        mc = _make_mock_client(post_resp=_resp(200, {"files": []}))
+        f1 = tmp_path / "a.txt"
+        f2 = tmp_path / "b.txt"
+        f1.write_text("a")
+        f2.write_text("b")
+        result = await a2a_tools_messaging._upload_chat_files(mc, [str(f1), str(f2)])
+        assert result[1] is not None
+        assert "0" in result[1]
+        assert "2" in result[1]
+
+    async def test_upload_success_returns_attachments_and_none(self, tmp_path):
+        """200 with the correct number of files returns the metadata list."""
+        import a2a_tools_messaging
+        expected = [{
+            "uri": "workspace:/workspace/.molecule/chat-uploads/test.txt",
+            "name": "test.txt",
+            "mimeType": "text/plain",
+            "size": 10,
+        }]
+        mc = _make_mock_client(post_resp=_resp(200, {"files": expected}))
+        f = tmp_path / "test.txt"
+        f.write_text("hello world")
+        result = await a2a_tools_messaging._upload_chat_files(mc, [str(f)])
+        assert result[0] == expected
+        assert result[1] is None
+
+    async def test_mime_type_guessed_from_filename(self, tmp_path):
+        """mimetype is sniffable from a .pdf extension."""
+        import a2a_tools_messaging
+        mc = _make_mock_client(post_resp=_resp(200, {
+            "files": [{"uri": "x", "name": "report.pdf", "mimeType": "application/pdf", "size": 100}],
+        }))
+        f = tmp_path / "report.pdf"
+        f.write_text("stub")
+        result = await a2a_tools_messaging._upload_chat_files(mc, [str(f)])
+        assert result[1] is None  # success
+        # Verify the POST was made with a multipart file.
+        call_args = mc.post.await_args
+        files_arg = call_args.kwargs.get("files")
+        assert files_arg is not None
+        assert any("report.pdf" in str(item) for item in files_arg)
+
+    async def test_unknown_extension_defaults_to_octet_stream(self, tmp_path):
+        """File with no extension gets application/octet-stream."""
+        import a2a_tools_messaging
+        mc = _make_mock_client(post_resp=_resp(200, {
+            "files": [{"uri": "x", "name": "blob", "mimeType": "application/octet-stream", "size": 5}],
+        }))
+        f = tmp_path / "blob"  # no extension
+        f.write_text("hello")
+        result = await a2a_tools_messaging._upload_chat_files(mc, [str(f)])
+        assert result[1] is None  # success
+
+
+# ---------------------------------------------------------------------------
+# tool_send_message_to_user — additional error paths (beyond test_a2a_tools_impl)
+# ---------------------------------------------------------------------------
+
+class TestToolSendMessageToUserMessaging:
+    """Error paths in tool_send_message_to_user not covered in test_a2a_tools_impl."""
+
+    async def test_upload_failure_prevents_notify_call(self, tmp_path):
+        """When _upload_chat_files returns an error, notify is never called."""
+        import a2a_tools_messaging
+        mc = _make_mock_client()
+        f = tmp_path / "gone.txt"
+        f.write_text("x")
+        f.chmod(0o000)
+        try:
+            with patch("a2a_tools_messaging.httpx.AsyncClient", return_value=mc):
+                result = await a2a_tools_messaging.tool_send_message_to_user(
+                    "Hi", attachments=[str(f)],
+                )
+            assert "Error" in result
+            # Permission-denied or "not found" — both halt before HTTP.
+            assert "permission denied" in result.lower() or "not found" in result.lower()
+            assert mc.post.await_count == 0
+        finally:
+            f.chmod(0o644)
+
+    async def test_403_talk_to_user_disabled_returns_detailed_error(self):
+        """403 with 'talk_to_user_disabled' returns the full error message."""
+        import a2a_tools_messaging
+        response = _resp(403, {
+            "error": "talk_to_user_disabled",
+            "hint": "Enable in workspace settings.",
+        })
+        mc = _make_mock_client(post_resp=response)
+        with patch("a2a_tools_messaging.httpx.AsyncClient", return_value=mc):
+            result = await a2a_tools_messaging.tool_send_message_to_user("Hi")
+        assert "not allowed" in result
+        assert "talk_to_user is disabled" in result
+        assert "Enable in workspace settings" in result
+
+    async def test_403_talk_to_user_disabled_without_hint(self):
+        """403 with 'talk_to_user_disabled' but no hint is still readable."""
+        import a2a_tools_messaging
+        response = _resp(403, {"error": "talk_to_user_disabled"})
+        mc = _make_mock_client(post_resp=response)
+        with patch("a2a_tools_messaging.httpx.AsyncClient", return_value=mc):
+            result = await a2a_tools_messaging.tool_send_message_to_user("Hi")
+        assert "not allowed" in result
+        assert "talk_to_user is disabled" in result
+
+    async def test_403_malformed_json_does_not_crash(self):
+        """403 where .json() raises still returns a sensible error."""
+        import a2a_tools_messaging
+        response = _resp(403, {})
+        response.json = lambda: (_ for _ in ()).throw(ValueError("boom"))
+        mc = _make_mock_client(post_resp=response)
+        with patch("a2a_tools_messaging.httpx.AsyncClient", return_value=mc):
+            result = await a2a_tools_messaging.tool_send_message_to_user("Hi")
+        # Falls through to the generic status code error.
+        assert "403" in result
+        assert "Error" in result