sync: 154 file da Baida98/AI@29e25a1b (2026-08-15 11:02 UTC) [deploy-all]

api/telegram_webhook.py

@@ -60,13 +60,24 @@ async def _tg_reply(chat_id: str | int, text: str, token: str | None = None,
         payload["reply_markup"] = keyboard
     try:
         import httpx
-        async with httpx.AsyncClient(timeout=8.0) as c:
-            await c.post(
+        timeout = httpx.Timeout(connect=5.0, read=15.0, write=10.0, pool=5.0)
+        # Il backend non richiede proxy HTTP per raggiungere l'API Telegram.
+        # Ignorare proxy d'ambiente evita ReadTimeout silenziosi in hosting gestiti.
+        async with httpx.AsyncClient(timeout=timeout, trust_env=False) as c:
+            response = await c.post(
                 f"https://api.telegram.org/bot{bot_token}/sendMessage",
                 json=payload,
             )
+        try:
+            data = response.json()
+        except ValueError:
+            data = {}
+        if response.status_code >= 400 or not data.get("ok", False):
+            detail = str(data.get("description") or response.text[:160] or "unknown")
+            _logger.warning("tg_reply rejected: status=%s detail=%s", response.status_code, detail)
     except Exception as exc:
-        _logger.warning("tg_reply error: %s", exc)
+        detail = str(exc) or repr(exc)
+        _logger.warning("tg_reply error: %s: %s", type(exc).__name__, detail)
 
 
 async def _tg_answer_callback(callback_query_id: str, text: str = "", token: str | None = None) -> None:

tests/test_telegram_reply_transport.py

@@ -0,0 +1,77 @@
+import unittest
+from unittest.mock import patch
+
+import httpx
+
+from api.telegram_webhook import _tg_reply
+
+
+class _Response:
+    def __init__(self, status_code=200, payload=None, text=""):
+        self.status_code = status_code
+        self._payload = payload if payload is not None else {"ok": True}
+        self.text = text
+
+    def json(self):
+        return self._payload
+
+
+class _Client:
+    instances = []
+    response = _Response()
+    exception = None
+
+    def __init__(self, **kwargs):
+        self.kwargs = kwargs
+        type(self).instances.append(self)
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, *_args):
+        return False
+
+    async def post(self, *_args, **_kwargs):
+        if type(self).exception is not None:
+            raise type(self).exception
+        return type(self).response
+
+
+class TelegramReplyTransportTests(unittest.IsolatedAsyncioTestCase):
+    def setUp(self):
+        _Client.instances = []
+        _Client.response = _Response()
+        _Client.exception = None
+
+    async def test_reply_bypasses_environment_proxy_and_accepts_success(self):
+        with patch("httpx.AsyncClient", _Client):
+            await _tg_reply(123, "<b>hello</b>", token="test-token")
+
+        self.assertEqual(len(_Client.instances), 1)
+        self.assertFalse(_Client.instances[0].kwargs["trust_env"])
+        self.assertIsInstance(_Client.instances[0].kwargs["timeout"], httpx.Timeout)
+
+    async def test_reply_logs_rejected_telegram_response(self):
+        _Client.response = _Response(
+            status_code=429,
+            payload={"ok": False, "description": "Too Many Requests"},
+        )
+        with patch("httpx.AsyncClient", _Client), self.assertLogs(
+            "api.telegram_webhook", level="WARNING"
+        ) as logs:
+            await _tg_reply(123, "hello", token="test-token")
+
+        self.assertIn("status=429 detail=Too Many Requests", "\n".join(logs.output))
+
+    async def test_reply_logs_timeout_type_when_transport_fails(self):
+        _Client.exception = httpx.ReadTimeout("")
+        with patch("httpx.AsyncClient", _Client), self.assertLogs(
+            "api.telegram_webhook", level="WARNING"
+        ) as logs:
+            await _tg_reply(123, "hello", token="test-token")
+
+        self.assertIn("ReadTimeout", "\n".join(logs.output))
+
+
+if __name__ == "__main__":
+    unittest.main()