feat: log raw telegram updates in development

tests/test_raw_updates.py

@@ -0,0 +1,106 @@
+import sqlite3
+import tempfile
+import unittest
+from pathlib import Path
+from unittest.mock import AsyncMock, patch
+
+from aiogram import Dispatcher
+from aiogram.types import Update
+
+import bot
+import raw_updates
+
+
+class RawUpdateStorageTests(unittest.TestCase):
+    def setUp(self):
+        self.temp_dir = tempfile.TemporaryDirectory()
+        self.db_path = str(Path(self.temp_dir.name) / "updates.sqlite3")
+        raw_updates.init_raw_updates_db(self.db_path)
+
+    def tearDown(self):
+        self.temp_dir.cleanup()
+
+    def test_save_and_read_update_by_id(self):
+        payload = {"update_id": 456, "message": {"message_id": 8, "text": "Привет"}}
+        raw_updates.save_raw_update(456, payload, self.db_path)
+        record = raw_updates.get_raw_update(456, self.db_path)
+        self.assertIsNotNone(record)
+        self.assertEqual(record["event_type"], "message")
+        self.assertEqual(record["payload"], payload)
+        self.assertIsNone(raw_updates.get_raw_update(999, self.db_path))
+
+    def test_sensitive_fields_are_redacted(self):
+        raw_updates.save_raw_update(
+            457,
+            {"update_id": 457, "message": {"text": "Bearer abc123", "token": "private"}},
+            self.db_path,
+        )
+        record = raw_updates.get_raw_update(457, self.db_path)
+        assert record is not None
+        self.assertEqual(record["payload"]["message"]["text"], "Bearer [REDACTED]")
+        self.assertEqual(record["payload"]["message"]["token"], "[REDACTED]")
+
+    def test_records_older_than_retention_are_removed(self):
+        raw_updates.save_raw_update(458, {"update_id": 458, "message": {}}, self.db_path)
+        with sqlite3.connect(self.db_path) as connection:
+            connection.execute(
+                "UPDATE raw_updates SET received_at = datetime('now', '-31 days') WHERE update_id = 458"
+            )
+        raw_updates.init_raw_updates_db(self.db_path)
+        self.assertIsNone(raw_updates.get_raw_update(458, self.db_path))
+
+
+class RawUpdateMiddlewareTests(unittest.IsolatedAsyncioTestCase):
+    async def test_update_is_persisted_before_handler(self):
+        update = Update.model_validate({
+            "update_id": 456,
+            "message": {
+                "message_id": 8,
+                "date": 1,
+                "chat": {"id": 42, "type": "private"},
+                "from": {"id": 42, "is_bot": False, "first_name": "Test"},
+                "text": "Привет",
+            },
+        })
+        temp_dir = tempfile.TemporaryDirectory()
+        self.addCleanup(temp_dir.cleanup)
+        db_path = str(Path(temp_dir.name) / "updates.sqlite3")
+        raw_updates.init_raw_updates_db(db_path)
+        middleware = raw_updates.RawUpdateMiddleware()
+
+        async def handler(event, data):
+            record = raw_updates.get_raw_update(456, db_path)
+            assert record is not None
+            self.assertEqual(record["payload"]["message"]["text"], "Привет")
+            return "handled"
+
+        with (
+            patch.object(raw_updates, "RAW_UPDATES_DB_PATH", db_path),
+            patch.object(raw_updates, "save_raw_update", wraps=raw_updates.save_raw_update) as save,
+        ):
+            result = await middleware(handler, update, {})
+        self.assertEqual(result, "handled")
+        save.assert_called_once()
+
+    async def test_persistence_failure_does_not_block_update(self):
+        middleware = raw_updates.RawUpdateMiddleware()
+        update = Update(update_id=459)
+        handler = AsyncMock(return_value="handled")
+        with patch.object(raw_updates, "save_raw_update", side_effect=OSError("disk full")):
+            self.assertEqual(await middleware(handler, update, {}), "handled")
+        handler.assert_awaited_once()
+
+
+class RawUpdateModeTests(unittest.TestCase):
+    def test_middleware_is_registered_only_for_development(self):
+        dispatcher = Dispatcher()
+        with patch.object(bot, "DEPLOY_ENV", "production"), patch.object(
+            dispatcher.update, "outer_middleware"
+        ) as register:
+            self.assertFalse(bot.configure_raw_update_logging(dispatcher))
+            register.assert_not_called()
+        with patch.object(bot, "DEPLOY_ENV", "development"), patch.object(
+            dispatcher.update, "outer_middleware"
+        ) as register:
+            self.assertTrue(bot.configure_raw_update_logging(dispatcher))
+            register.assert_called_once()