feat: add verification clearance notifications to warning topic

- Add new VERIFICATION_CLEARANCE_MESSAGE constant to announce user verification
- Update verify handler to send notification to warning topic when user has warnings
- Include user mention in clearance message using mention_markdown
- Add new test fixtures and helper methods to verify command tests
- Update fixture to use autouse=True for proper database setup
- Add comprehensive test coverage for clearance notifications
  - Test notification sent when user has previous warnings
  - Test no notification sent when user has no warnings
- Update README test statistics (208 tests, 700 statements, 100% coverage)

Author: rezhajulio

README.md

@@ -135,9 +135,9 @@ uv run pytest -v
 ### Test Coverage
 
 The project maintains comprehensive test coverage:
-- **Coverage**: 100% across all modules (692 statements, 0 missed)
-- **Tests**: 206 total
-- **Pass Rate**: 100% (206/206 passed)
+- **Coverage**: 100% across all modules (700 statements, 0 missed)
+- **Tests**: 208 total
+- **Pass Rate**: 100% (208/208 passed)
 - **All modules**: 100% coverage including JobQueue scheduler integration and captcha verification
   - Services: `bot_info.py`, `scheduler.py`, `user_checker.py`, `telegram_utils.py`, `captcha_recovery.py`
   - Handlers: `captcha.py`, `dm.py`, `message.py`, `topic_guard.py`, `verify.py`

src/bot/constants.py

@@ -130,3 +130,7 @@ def format_threshold_display(threshold_minutes: int) -> str:
     "✅ Selamat! Kamu sudah memenuhi persyaratan.\n"
     "Pembatasan kamu di grup telah dicabut. Silakan bergabung kembali!"
 )
+
+VERIFICATION_CLEARANCE_MESSAGE = (
+    "✅ {user_mention} telah diverifikasi oleh admin. Silakan berdiskusi kembali."
+)

src/bot/handlers/verify.py

@@ -11,8 +11,10 @@
 from telegram import Update
 from telegram.error import BadRequest
 from telegram.ext import ContextTypes
+from telegram.helpers import mention_markdown
 
 from bot.config import get_settings
+from bot.constants import VERIFICATION_CLEARANCE_MESSAGE
 from bot.database.service import get_database
 from bot.services.telegram_utils import unrestrict_user
 
@@ -85,7 +87,24 @@ async def handle_verify_command(
 
         # Delete all warning records for this user
         deleted_count = db.delete_user_warnings(target_user_id, settings.group_id)
+        
+        # Send notification to warning topic if user had previous warnings
         if deleted_count > 0:
+            # Get user info for proper mention
+            user_info = await context.bot.get_chat(target_user_id)
+            user_mention = mention_markdown(target_user_id, user_info.full_name, version=2)
+            
+            # Send clearance message to warning topic
+            clearance_message = VERIFICATION_CLEARANCE_MESSAGE.format(
+                user_mention=user_mention
+            )
+            await context.bot.send_message(
+                chat_id=settings.group_id,
+                message_thread_id=settings.warning_topic_id,
+                text=clearance_message,
+                parse_mode="Markdown"
+            )
+            logger.info(f"Sent clearance notification to warning topic for user {target_user_id}")
             logger.info(f"Deleted {deleted_count} warning record(s) for user {target_user_id}")
 
         await update.message.reply_text(

tests/test_verify_handler.py

@@ -8,10 +8,11 @@
 from bot.handlers.verify import handle_unverify_command, handle_verify_command
 
 
-@pytest.fixture
+@pytest.fixture(autouse=True)
 def temp_db():
     with tempfile.TemporaryDirectory() as tmpdir:
         db_path = Path(tmpdir) / "test.db"
+        reset_database()  # Reset before init
         init_database(str(db_path))
         yield db_path
         reset_database()
@@ -36,8 +37,9 @@ def mock_context():
     context.bot = MagicMock()
     context.bot.get_chat = AsyncMock()
     context.bot.restrict_chat_member = AsyncMock()
+    context.bot.send_message = AsyncMock()
 
-    # Mock get_chat to return a chat with default permissions
+    # Mock get_chat to return both chat permissions and user info
     mock_chat = MagicMock()
     mock_permissions = MagicMock()
     mock_permissions.can_send_messages = True
@@ -48,6 +50,7 @@ def mock_context():
     mock_permissions.can_invite_users = True
     mock_permissions.can_pin_messages = False
     mock_chat.permissions = mock_permissions
+    mock_chat.full_name = "Test User"
     context.bot.get_chat.return_value = mock_chat
 
     context.bot_data = {"admin_ids": [12345]}
@@ -112,8 +115,16 @@ async def test_invalid_user_id_format(self, mock_update, mock_context):
         call_args = mock_update.message.reply_text.call_args
         assert "angka" in call_args.args[0]
 
-    async def test_successful_verify_new_user(self, mock_update, mock_context, temp_db):
-        target_user_id = 555666
+    async def test_successful_verify_new_user(self, mock_update, mock_context, temp_db, monkeypatch):
+        # Mock the settings
+        class MockSettings:
+            group_id = -1001234567890
+            warning_topic_id = 12345
+            telegram_bot_token = "fake_token"
+        
+        monkeypatch.setattr("bot.handlers.verify.get_settings", lambda: MockSettings())
+        
+        target_user_id = 11111111  # Use unique ID
         mock_context.args = [str(target_user_id)]
 
         await handle_verify_command(mock_update, mock_context)
@@ -173,8 +184,17 @@ async def test_verify_respects_admin_ids(self, mock_update, mock_context):
         call_args = mock_update.message.reply_text.call_args
         assert "izin" in call_args.args[0]
 
-    async def test_verify_with_extra_args_uses_first(self, mock_update, mock_context, temp_db):
-        mock_context.args = ["555666", "extra", "args"]
+    async def test_verify_with_extra_args_uses_first(self, mock_update, mock_context, temp_db, monkeypatch):
+        # Mock the settings
+        class MockSettings:
+            group_id = -1001234567890
+            warning_topic_id = 12345
+            telegram_bot_token = "fake_token"
+        
+        monkeypatch.setattr("bot.handlers.verify.get_settings", lambda: MockSettings())
+        
+        target_user_id = 22222222  # Use unique ID
+        mock_context.args = [str(target_user_id), "extra", "args"]
 
         await handle_verify_command(mock_update, mock_context)
 
@@ -183,7 +203,7 @@ async def test_verify_with_extra_args_uses_first(self, mock_update, mock_context
         assert "diverifikasi" in call_args.args[0]
 
         db = get_database()
-        assert db.is_user_photo_whitelisted(555666)
+        assert db.is_user_photo_whitelisted(target_user_id)
 
     async def test_verify_large_user_id(self, mock_update, mock_context, temp_db):
         large_id = 9999999999
@@ -194,9 +214,17 @@ async def test_verify_large_user_id(self, mock_update, mock_context, temp_db):
         db = get_database()
         assert db.is_user_photo_whitelisted(large_id)
 
-    async def test_verify_unrestricts_user(self, mock_update, mock_context, temp_db):
+    async def test_verify_unrestricts_user(self, mock_update, mock_context, temp_db, monkeypatch):
         """Test that verify command unrestricts the user."""
-        target_user_id = 555666
+        # Mock the settings
+        class MockSettings:
+            group_id = -1001234567890
+            warning_topic_id = 12345
+            telegram_bot_token = "fake_token"
+        
+        monkeypatch.setattr("bot.handlers.verify.get_settings", lambda: MockSettings())
+        
+        target_user_id = 33333333  # Use unique ID
         mock_context.args = [str(target_user_id)]
 
         await handle_verify_command(mock_update, mock_context)
@@ -207,37 +235,50 @@ async def test_verify_unrestricts_user(self, mock_update, mock_context, temp_db)
         assert call_args.kwargs["user_id"] == target_user_id
         assert call_args.kwargs["permissions"].can_send_messages is True
 
-    async def test_verify_deletes_warnings(self, mock_update, mock_context, temp_db):
+    async def test_verify_deletes_warnings(self, mock_update, mock_context, temp_db, monkeypatch):
         """Test that verify command deletes all warning records."""
-        from bot.config import get_settings
+        # Mock the settings
+        class MockSettings:
+            group_id = -1001234567890
+            warning_topic_id = 12345
+            telegram_bot_token = "fake_token"
 
-        target_user_id = 555666
-        settings = get_settings()
+        monkeypatch.setattr("bot.handlers.verify.get_settings", lambda: MockSettings())
+        
+        target_user_id = 66666666  # Use unique ID
         db = get_database()
 
         # Create some warning records for the user
-        db.get_or_create_user_warning(target_user_id, settings.group_id)
-        db.increment_message_count(target_user_id, settings.group_id)
+        db.get_or_create_user_warning(target_user_id, MockSettings.group_id)
+        db.increment_message_count(target_user_id, MockSettings.group_id)
 
         # Verify there's at least one warning
-        warning = db.get_or_create_user_warning(target_user_id, settings.group_id)
+        warning = db.get_or_create_user_warning(target_user_id, MockSettings.group_id)
         assert warning.message_count >= 1
 
         # Now verify the user
         mock_context.args = [str(target_user_id)]
         await handle_verify_command(mock_update, mock_context)
 
         # Warnings should be deleted - trying to get warnings should create a new one
-        new_warning = db.get_or_create_user_warning(target_user_id, settings.group_id)
+        new_warning = db.get_or_create_user_warning(target_user_id, MockSettings.group_id)
         assert new_warning.message_count == 1  # Fresh start
 
     async def test_verify_handles_non_restricted_user_gracefully(
-        self, mock_update, mock_context, temp_db
+        self, mock_update, mock_context, temp_db, monkeypatch
     ):
         """Test that verify doesn't fail if user is not restricted."""
         from telegram.error import BadRequest
 
-        target_user_id = 555666
+        # Mock the settings
+        class MockSettings:
+            group_id = -1001234567890
+            warning_topic_id = 12345
+            telegram_bot_token = "fake_token"
+        
+        monkeypatch.setattr("bot.handlers.verify.get_settings", lambda: MockSettings())
+        
+        target_user_id = 44444444  # Use unique ID
         mock_context.args = [str(target_user_id)]
 
         # Simulate BadRequest when trying to unrestrict a non-restricted user
@@ -255,6 +296,60 @@ async def test_verify_handles_non_restricted_user_gracefully(
         call_args = mock_update.message.reply_text.call_args
         assert "diverifikasi" in call_args.args[0]
 
+    async def test_verify_with_warnings_sends_notification_to_topic(
+        self, mock_update, mock_context, temp_db, monkeypatch
+    ):
+        """Test that verify sends notification to warning topic when user has warnings."""
+        # Mock the settings
+        class MockSettings:
+            group_id = -1001234567890
+            warning_topic_id = 12345
+            telegram_bot_token = "fake_token"
+        
+        monkeypatch.setattr("bot.handlers.verify.get_settings", lambda: MockSettings())
+        
+        target_user_id = 77777777  # Use unique ID
+        db = get_database()
+
+        # Create warning records for the user
+        db.get_or_create_user_warning(target_user_id, MockSettings.group_id)
+        db.increment_message_count(target_user_id, MockSettings.group_id)
+        db.increment_message_count(target_user_id, MockSettings.group_id)
+
+        # Now verify the user
+        mock_context.args = [str(target_user_id)]
+        await handle_verify_command(mock_update, mock_context)
+
+        # Should send notification to warning topic
+        mock_context.bot.send_message.assert_called_once()
+        call_args = mock_context.bot.send_message.call_args
+        assert call_args.kwargs["chat_id"] == MockSettings.group_id
+        assert call_args.kwargs["message_thread_id"] == MockSettings.warning_topic_id
+        assert call_args.kwargs["parse_mode"] == "Markdown"
+        # Check the message contains user mention
+        assert "Test User" in call_args.kwargs["text"] or str(target_user_id) in call_args.kwargs["text"]
+
+    async def test_verify_without_warnings_no_notification(
+        self, mock_update, mock_context, temp_db, monkeypatch
+    ):
+        """Test that verify doesn't send notification when user has no warnings."""
+        # Mock the settings
+        class MockSettings:
+            group_id = -1001234567890
+            warning_topic_id = 12345
+            telegram_bot_token = "fake_token"
+        
+        monkeypatch.setattr("bot.handlers.verify.get_settings", lambda: MockSettings())
+        
+        target_user_id = 88888888  # Use unique ID
+        mock_context.args = [str(target_user_id)]
+
+        # Verify user without any warnings
+        await handle_verify_command(mock_update, mock_context)
+
+        # Should NOT send notification to warning topic
+        mock_context.bot.send_message.assert_not_called()
+
 
 class TestHandleUnverifyCommand:
     async def test_no_message(self, mock_context):