Do not create DomainAddress if the address was previously deleted

emails/models.py

@@ -709,11 +709,11 @@ def valid_address_pattern(address):
     return valid_address_pattern.match(address) is not None
 
 
-def valid_address(address: str, domain: str) -> bool:
+def valid_address(address: str, domain: str, subdomain: str | None = None) -> bool:
     address_pattern_valid = valid_address_pattern(address)
     address_contains_badword = has_bad_words(address)
     address_already_deleted = DeletedAddress.objects.filter(
-        address_hash=address_hash(address, domain=domain)
+        address_hash=address_hash(address, domain=domain, subdomain=subdomain)
     ).count()
     if (
         address_already_deleted > 0
@@ -776,9 +776,10 @@ class DomainAddress(models.Model):
         user_profile = self.user.profile
         if self._state.adding:
             check_user_can_make_domain_address(user_profile)
-            pattern_valid = valid_address_pattern(self.address)
-            address_contains_badword = has_bad_words(self.address)
-            if not pattern_valid or address_contains_badword:
+            domain_address_valid = valid_address(
+                self.address, self.domain_value, user_profile.subdomain
+            )
+            if not domain_address_valid:
                 raise DomainAddrUnavailableException(unavailable_address=self.address)
             user_profile.update_abuse_metric(address_created=True)
         if not user_profile.has_premium:

emails/tests/models_tests.py

@@ -21,6 +21,7 @@ from ..models import (
     CannotMakeSubdomainException,
     DeletedAddress,
     DomainAddress,
+    DomainAddrUnavailableException,
     emails_config,
     get_domains_from_settings,
     get_domain_numerical,
@@ -265,6 +266,20 @@ class RelayAddressTest(TestCase):
         relay_address.delete()
         assert not valid_address(relay_address.address, relay_address.domain_value)
 
+    def test_dupe_domain_address_of_deleted_invalid(self):
+        user = make_premium_test_user()
+        user_profile = user.profile
+        user_profile.subdomain = "test"
+        user_profile.save()
+        address = "same-address"
+        domain_address = DomainAddress.make_domain_address(
+            user_profile, address=address
+        )
+        domain_address.delete()
+        assert not valid_address(
+            address, domain_address.domain_value, user_profile.subdomain
+        )
+
     @patch.object(emails_config, "blocklist", ["blocked-word"])
     def test_address_contains_blocklist_invalid(self) -> None:
         blocked_word = "blocked-word"
@@ -1025,16 +1040,20 @@ class DomainAddressTest(TestCase):
             DomainAddress.make_domain_address(user_profile, "test-nosubdomain")
         assert exc_info.value.get_codes() == "need_subdomain"
 
-    @patch.multiple("string", ascii_lowercase="a", digits="")
-    def test_make_domain_address_makes_dupe_of_deleted(self):
-        test_hash = address_hash("aaaaaaaaa", self.subdomain)
-        DeletedAddress.objects.create(address_hash=test_hash)
-        domain_address = DomainAddress.make_domain_address(self.user_profile)
+    def test_make_domain_address_cannot_make_dupe_of_deleted(self):
+        address = "same-address"
+        domain_address = DomainAddress.make_domain_address(
+            self.user_profile, address=address
+        )
         domain_address_hash = address_hash(
             domain_address.address,
             domain_address.user_profile.subdomain,
             domain_address.domain_value,
         )
+        domain_address.delete()
+        with pytest.raises(DomainAddrUnavailableException) as exc_info:
+            DomainAddress.make_domain_address(self.user_profile, address=address)
+        assert exc_info.value.get_codes() == "address_unavailable"
         assert (
             DeletedAddress.objects.filter(address_hash=domain_address_hash).count() == 1
         )