Upload folder using huggingface_hub

app/validator/mailbox_provider.py

@@ -44,8 +44,14 @@ def map_mv_result(payload: dict) -> SMTPResult:
         return SMTPResult(verified=True, smtp_code=250, smtp_message="provider: ok")
     if result == "invalid":
         # A provider-confirmed dead mailbox is a permanent (5xx-class) reject.
+        # The message MUST carry an explicit mailbox-rejection phrase so
+        # scoring._is_explicit_mailbox_rejection() hard-fails it to score 0
+        # (Invalid) — a bare "invalid" would be softened to -30 "inconclusive"
+        # and mis-score a definitive answer as risky.
         return SMTPResult(
-            verified=False, smtp_code=550, smtp_message=error or "provider: invalid"
+            verified=False,
+            smtp_code=550,
+            smtp_message=error or "550 mailbox does not exist (provider confirmed)",
         )
     if result in {"catch_all", "unknown", "disposable"}:
         # None of these proves the specific mailbox exists. catch_all accepts

tests/test_mailbox_provider.py

@@ -27,6 +27,15 @@ class MapMVResultTests(unittest.TestCase):
         self.assertFalse(r.verified)
         self.assertEqual(r.smtp_code, 550)
 
+    def test_invalid_carries_explicit_rejection_phrase(self):
+        # A provider-confirmed dead mailbox must score 0 (Invalid), not be
+        # softened to -30 "inconclusive". calculate_score() only hard-fails a
+        # 5xx when the message carries an explicit mailbox-rejection phrase, so
+        # the adapter must supply one — otherwise a definitive "invalid" is
+        # mis-scored as risky/valid.
+        r = map_mv_result({"result": "invalid", "quality": "bad", "resultcode": 4})
+        self.assertIn("does not exist", (r.smtp_message or "").lower())
+
     def test_catch_all_maps_to_inconclusive(self):
         # A catch-all domain accepts the probe but proves nothing about the
         # specific mailbox — it must NOT read as verified.
@@ -78,6 +87,45 @@ class MillionVerifierProviderTests(unittest.IsolatedAsyncioTestCase):
         self.assertGreater(confidence, 0.5)
 
 
+class EngineProviderVerdictTests(unittest.IsolatedAsyncioTestCase):
+    """End-to-end: a provider-confirmed dead mailbox must hard-fail to score 0
+    (Invalid) through the whole engine, not be softened to 'risky' (the live
+    mis-score observed before the adapter supplied an explicit rejection phrase)."""
+
+    async def test_provider_invalid_scores_zero(self):
+        from unittest.mock import AsyncMock, patch as _patch
+        from app.models import DNSResult, DisposableResult, SyntaxResult
+        from app.validator.engine import EmailValidationEngine
+
+        engine = EmailValidationEngine(mailbox=MillionVerifierProvider(api_key="k"))
+
+        class DeadMailboxProvider:
+            async def verify(self, email, mx_host):
+                return map_mv_result({"result": "invalid", "resultcode": 4})
+            async def catch_all(self, domain, mx_host):
+                return (False, 0.9)
+
+        engine.mailbox = DeadMailboxProvider()
+        with (
+            _patch("app.validator.engine.validate_syntax", return_value=SyntaxResult(
+                passed=True, normalized_email="a@example.test",
+                domain="example.test", local_part="a",
+            )),
+            _patch("app.validator.engine.check_dns", new=AsyncMock(return_value=DNSResult(
+                domain_exists=True, has_mx_records=True,
+                mx_records=[{"host": "mx.example.test", "priority": 10}],
+            ))),
+            _patch("app.validator.engine.check_disposable", return_value=DisposableResult(
+                is_disposable=False, is_free_provider=False, is_role_based=False,
+            )),
+        ):
+            result = await engine.validate("a@example.test", deep=True)
+
+        self.assertEqual(result.scoring.score, 0)
+        self.assertEqual(result.status.value, "invalid")
+        self.assertEqual(result.reason_code, "rcpt_5xx")
+
+
 class ResolveProviderTests(unittest.TestCase):
     def test_api_forced(self):
         with patch.object(settings, "mailbox_provider", "api"), patch.object(