test: add unit coverage + focused integration tests for safety wrappers

Addresses CI failures on PR #62:
- codecov/patch failed (50% diff hit): the new methods had only
  callable() smoke tests in test_client.py, which don't execute the
  method bodies. Add proper request-mocking unit tests in
  test_api_methods.py (sync) and test_async_client.py (async)
  matching the existing test_follow / test_unfollow shape.
- lint failed (ruff SIM108): collapse the if/else block in
  tests/integration/test_safety.py::_target_in_blocked into a ternary.

Also adds focused integration tests per individual method so each
of block_user / list_blocked / unblock_user has its own named test
on top of the existing block-then-unblock round-trip:
- TestBlockUser::test_block_user_adds_to_blocked_list
- TestListBlocked::test_list_blocked_returns_collection
- TestUnblockUser::test_unblock_user_removes_from_blocked_list
- TestReportSmoke::test_report_methods_are_present_on_live_client

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

Author: ColonistOne

tests/integration/test_safety.py

@@ -25,10 +25,7 @@ def _target_in_blocked(blocked_response: object, target_id: str) -> bool:
     """
     if isinstance(blocked_response, dict):
         items = blocked_response.get("items")
-        if isinstance(items, list):
-            members = items
-        else:
-            members = []
+        members = items if isinstance(items, list) else []
     elif isinstance(blocked_response, list):
         members = blocked_response
     else:
@@ -41,7 +38,52 @@ def _target_in_blocked(blocked_response: object, target_id: str) -> bool:
     return False
 
 
-class TestBlock:
+class TestBlockUser:
+    """Focused tests for ``block_user`` against the live API."""
+
+    def test_block_user_adds_to_blocked_list(self, client: ColonyClient, second_me: dict) -> None:
+        target_id = second_me["id"]
+
+        # Best-effort cleanup from a previous failed run.
+        with contextlib.suppress(ColonyAPIError):
+            client.unblock_user(target_id)
+
+        try:
+            client.block_user(target_id)
+            assert _target_in_blocked(client.list_blocked(), target_id)
+        finally:
+            with contextlib.suppress(ColonyAPIError):
+                client.unblock_user(target_id)
+
+
+class TestListBlocked:
+    """Focused tests for ``list_blocked`` against the live API."""
+
+    def test_list_blocked_returns_collection(self, client: ColonyClient) -> None:
+        result = client.list_blocked()
+        # The endpoint should return either {items: [...]} or a list — both
+        # shapes are accepted by the SDK type. Validate it's one of them.
+        if isinstance(result, dict):
+            assert "items" in result or "total" in result
+        else:
+            assert isinstance(result, list)
+
+
+class TestUnblockUser:
+    """Focused tests for ``unblock_user`` against the live API."""
+
+    def test_unblock_user_removes_from_blocked_list(self, client: ColonyClient, second_me: dict) -> None:
+        target_id = second_me["id"]
+
+        # Make sure the user is currently blocked.
+        with contextlib.suppress(ColonyAPIError):
+            client.block_user(target_id)
+
+        client.unblock_user(target_id)
+        assert not _target_in_blocked(client.list_blocked(), target_id)
+
+
+class TestBlockUnblockRoundTrip:
     def test_block_then_unblock(self, client: ColonyClient, second_me: dict) -> None:
         target_id = second_me["id"]
 
@@ -83,3 +125,20 @@ def test_unblock_when_not_blocked_raises(self, client: ColonyClient, second_me:
 
         with raises_status(404, 409):
             client.unblock_user(target_id)
+
+
+class TestReportSmoke:
+    """Smoke check that the report_* methods are reachable.
+
+    We intentionally do NOT submit a real report against the secondary
+    account in CI — that would generate operator-side moderation noise
+    on every run. The unit tests in ``tests/test_api_methods.py``
+    exercise the request construction; this just confirms the methods
+    are wired on the live client without invoking them.
+    """
+
+    def test_report_methods_are_present_on_live_client(self, client: ColonyClient) -> None:
+        assert callable(client.report_user)
+        assert callable(client.report_message)
+        assert callable(client.report_post)
+        assert callable(client.report_comment)

tests/test_api_methods.py

@@ -1022,6 +1022,98 @@ def test_unfollow(self, mock_urlopen: MagicMock) -> None:
         assert req.full_url == f"{BASE}/users/u1/follow"
 
 
+# ---------------------------------------------------------------------------
+# Safety / Moderation
+# ---------------------------------------------------------------------------
+
+
+class TestSafety:
+    @patch("colony_sdk.client.urlopen")
+    def test_block_user(self, mock_urlopen: MagicMock) -> None:
+        mock_urlopen.return_value = _mock_response({"blocked": True})
+        client = _authed_client()
+
+        client.block_user("u1")
+
+        req = _last_request(mock_urlopen)
+        assert req.get_method() == "POST"
+        assert req.full_url == f"{BASE}/users/u1/block"
+
+    @patch("colony_sdk.client.urlopen")
+    def test_unblock_user(self, mock_urlopen: MagicMock) -> None:
+        mock_urlopen.return_value = _mock_response({"blocked": False})
+        client = _authed_client()
+
+        client.unblock_user("u1")
+
+        req = _last_request(mock_urlopen)
+        assert req.get_method() == "DELETE"
+        assert req.full_url == f"{BASE}/users/u1/block"
+
+    @patch("colony_sdk.client.urlopen")
+    def test_list_blocked(self, mock_urlopen: MagicMock) -> None:
+        mock_urlopen.return_value = _mock_response({"items": [], "total": 0})
+        client = _authed_client()
+
+        client.list_blocked()
+
+        req = _last_request(mock_urlopen)
+        assert req.get_method() == "GET"
+        assert req.full_url == f"{BASE}/users/me/blocked"
+
+    @patch("colony_sdk.client.urlopen")
+    def test_report_user(self, mock_urlopen: MagicMock) -> None:
+        mock_urlopen.return_value = _mock_response({"id": "r1", "status": "received"})
+        client = _authed_client()
+
+        client.report_user("u1", reason="spam")
+
+        req = _last_request(mock_urlopen)
+        assert req.get_method() == "POST"
+        assert req.full_url == f"{BASE}/reports"
+        body = _last_body(mock_urlopen)
+        assert body == {"target_type": "user", "target_id": "u1", "reason": "spam"}
+
+    @patch("colony_sdk.client.urlopen")
+    def test_report_message(self, mock_urlopen: MagicMock) -> None:
+        mock_urlopen.return_value = _mock_response({"id": "r1", "status": "received"})
+        client = _authed_client()
+
+        client.report_message("m1", reason="abuse")
+
+        req = _last_request(mock_urlopen)
+        assert req.get_method() == "POST"
+        assert req.full_url == f"{BASE}/reports"
+        body = _last_body(mock_urlopen)
+        assert body == {"target_type": "message", "target_id": "m1", "reason": "abuse"}
+
+    @patch("colony_sdk.client.urlopen")
+    def test_report_post(self, mock_urlopen: MagicMock) -> None:
+        mock_urlopen.return_value = _mock_response({"id": "r1", "status": "received"})
+        client = _authed_client()
+
+        client.report_post("p1", reason="low-effort")
+
+        req = _last_request(mock_urlopen)
+        assert req.get_method() == "POST"
+        assert req.full_url == f"{BASE}/reports"
+        body = _last_body(mock_urlopen)
+        assert body == {"target_type": "post", "target_id": "p1", "reason": "low-effort"}
+
+    @patch("colony_sdk.client.urlopen")
+    def test_report_comment(self, mock_urlopen: MagicMock) -> None:
+        mock_urlopen.return_value = _mock_response({"id": "r1", "status": "received"})
+        client = _authed_client()
+
+        client.report_comment("c1", reason="harassment")
+
+        req = _last_request(mock_urlopen)
+        assert req.get_method() == "POST"
+        assert req.full_url == f"{BASE}/reports"
+        body = _last_body(mock_urlopen)
+        assert body == {"target_type": "comment", "target_id": "c1", "reason": "harassment"}
+
+
 # ---------------------------------------------------------------------------
 # Notifications
 # ---------------------------------------------------------------------------

tests/test_async_client.py

@@ -1009,6 +1009,93 @@ def handler(request: httpx.Request) -> httpx.Response:
         await client.unfollow("u2")
         assert seen["method"] == "DELETE"
 
+    async def test_block_user(self) -> None:
+        seen: dict = {}
+
+        def handler(request: httpx.Request) -> httpx.Response:
+            seen["url"] = str(request.url)
+            seen["method"] = request.method
+            return _json_response({"blocked": True})
+
+        client = _make_client(handler)
+        await client.block_user("u2")
+        assert "/users/u2/block" in seen["url"]
+        assert seen["method"] == "POST"
+
+    async def test_unblock_user(self) -> None:
+        seen: dict = {}
+
+        def handler(request: httpx.Request) -> httpx.Response:
+            seen["url"] = str(request.url)
+            seen["method"] = request.method
+            return _json_response({"blocked": False})
+
+        client = _make_client(handler)
+        await client.unblock_user("u2")
+        assert "/users/u2/block" in seen["url"]
+        assert seen["method"] == "DELETE"
+
+    async def test_list_blocked(self) -> None:
+        seen: dict = {}
+
+        def handler(request: httpx.Request) -> httpx.Response:
+            seen["url"] = str(request.url)
+            seen["method"] = request.method
+            return _json_response({"items": [], "total": 0})
+
+        client = _make_client(handler)
+        await client.list_blocked()
+        assert "/users/me/blocked" in seen["url"]
+        assert seen["method"] == "GET"
+
+    async def test_report_user(self) -> None:
+        seen: dict = {}
+
+        def handler(request: httpx.Request) -> httpx.Response:
+            seen["url"] = str(request.url)
+            seen["method"] = request.method
+            seen["body"] = json.loads(request.content.decode())
+            return _json_response({"id": "r1", "status": "received"})
+
+        client = _make_client(handler)
+        await client.report_user("u2", reason="spam")
+        assert "/reports" in seen["url"]
+        assert seen["method"] == "POST"
+        assert seen["body"] == {"target_type": "user", "target_id": "u2", "reason": "spam"}
+
+    async def test_report_message(self) -> None:
+        seen: dict = {}
+
+        def handler(request: httpx.Request) -> httpx.Response:
+            seen["body"] = json.loads(request.content.decode())
+            return _json_response({"id": "r1", "status": "received"})
+
+        client = _make_client(handler)
+        await client.report_message("m1", reason="abuse")
+        assert seen["body"] == {"target_type": "message", "target_id": "m1", "reason": "abuse"}
+
+    async def test_report_post(self) -> None:
+        seen: dict = {}
+
+        def handler(request: httpx.Request) -> httpx.Response:
+            seen["body"] = json.loads(request.content.decode())
+            return _json_response({"id": "r1", "status": "received"})
+
+        client = _make_client(handler)
+        await client.report_post("p1", reason="low-effort")
+        assert seen["body"] == {"target_type": "post", "target_id": "p1", "reason": "low-effort"}
+
+    async def test_report_comment(self) -> None:
+        seen: dict = {}
+
+        def handler(request: httpx.Request) -> httpx.Response:
+            seen["body"] = json.loads(request.content.decode())
+            return _json_response({"id": "r1", "status": "received"})
+
+        client = _make_client(handler)
+        await client.report_comment("c1", reason="harassment")
+        assert seen["body"] == {"target_type": "comment", "target_id": "c1", "reason": "harassment"}
+
     async def test_join_colony(self) -> None:
         seen: dict = {}