From 80fe3b6f6bf2adda603d704633a70bdbb7a4f006 Mon Sep 17 00:00:00 2001 From: Ben McIlwain Date: Wed, 18 Nov 2026 14:41:40 -0500 Subject: [PATCH] Clarify bulk compliance day-40 warning logic Fix the inverted inline comment introduced in PR #2422 and replace the opaque Integer.MAX_VALUE sentinel in CheckBulkComplianceAction's handleActiveDomainOverage() with explicit control flow across all four notification states: - Never notified (Optional.empty()): send initial 30-day cure warning. - < 30 days since last notification: cure window active, send nothing. - 30-39 days since last notification: uncured warning, send upgrade notice. - >= 40 days since last notification: prior violation was cured during days 30-39 (lastNotificationSent is not cleared when activeDomains returns below maxDomains), so treat as a new violation episode and send a fresh 30-day warning. Add unit tests in CheckBulkComplianceActionTest covering never-notified packages and exact day-29, day-30, day-39, and day-40 boundaries. BUG= http://b/586480278 --- .../batch/CheckBulkComplianceAction.java | 33 ++-- .../batch/CheckBulkComplianceActionTest.java | 171 +++++++++++++++++- 2 files changed, 192 insertions(+), 12 deletions(-) diff --git a/core/src/main/java/google/registry/batch/CheckBulkComplianceAction.java b/core/src/main/java/google/registry/batch/CheckBulkComplianceAction.java index 129798ab628..cd0543fdaf3 100644 --- a/core/src/main/java/google/registry/batch/CheckBulkComplianceAction.java +++ b/core/src/main/java/google/registry/batch/CheckBulkComplianceAction.java @@ -33,6 +33,7 @@ import google.registry.util.Clock; import jakarta.inject.Inject; import java.time.Duration; +import java.time.Instant; import java.util.Optional; /** @@ -56,7 +57,9 @@ public class CheckBulkComplianceAction implements Runnable { private final String bulkPricingPackageDomainLimitWarningEmailBody; private final String bulkPricingPackageDomainLimitUpgradeEmailBody; private final String registrySupportEmail; + // Registrars receive a 30-day cure window after an active-domain overage warning before upgrade. private static final int THIRTY_DAYS = 30; + // Notifications 40+ days old indicate the prior 30-39 day upgrade window passed without overage. private static final int FORTY_DAYS = 40; @Inject @@ -182,18 +185,26 @@ private void handleActiveDomainOverage(ImmutableMap ov logger.atInfo().log( "Found %d bulk pricing packages over their active domains limit.", overageList.size()); for (BulkPricingPackage bulkPricingPackage : overageList.keySet()) { - int daysSinceLastNotification = - bulkPricingPackage - .getLastNotificationSent() - .map(sentDate -> (int) Duration.between(sentDate, clock.now()).toDays()) - .orElse(Integer.MAX_VALUE); - // Send a warning email if 30-39 days since last notification and an upgrade email if 40+ days - if (daysSinceLastNotification >= THIRTY_DAYS) { - sendActiveDomainOverageEmail( - /* warning= */ daysSinceLastNotification >= FORTY_DAYS, - bulkPricingPackage, - overageList.get(bulkPricingPackage)); + long activeDomains = overageList.get(bulkPricingPackage); + Optional lastNotificationSent = bulkPricingPackage.getLastNotificationSent(); + if (lastNotificationSent.isEmpty()) { + // First active-domain overage for this package: send initial 30-day cure warning. + sendActiveDomainOverageEmail(/* warning= */ true, bulkPricingPackage, activeDomains); + continue; } + long daysSinceLastNotification = + Duration.between(lastNotificationSent.get(), clock.now()).toDays(); + if (daysSinceLastNotification < THIRTY_DAYS) { + // Still within the 30-day cure window after a warning; do not send another email yet. + continue; + } + // Because lastNotificationSent is not cleared when a package returns below maxDomains, + // an elapsed interval of 30-39 days means the warning went uncured and requires an upgrade + // notice, whereas 40+ days means the prior violation was cured during days 30-39 and this + // is a new overage episode warranting a fresh 30-day warning. + boolean isNewViolationEpisode = daysSinceLastNotification >= FORTY_DAYS; + sendActiveDomainOverageEmail( + /* warning= */ isNewViolationEpisode, bulkPricingPackage, activeDomains); } } diff --git a/core/src/test/java/google/registry/batch/CheckBulkComplianceActionTest.java b/core/src/test/java/google/registry/batch/CheckBulkComplianceActionTest.java index 5a1ddf73672..19adbad7108 100644 --- a/core/src/test/java/google/registry/batch/CheckBulkComplianceActionTest.java +++ b/core/src/test/java/google/registry/batch/CheckBulkComplianceActionTest.java @@ -56,7 +56,8 @@ /** Unit tests for {@link CheckBulkComplianceAction}. */ public class CheckBulkComplianceActionTest { // This is the default creation time for test data. - private final FakeClock clock = new FakeClock(Instant.parse("2012-03-25T00:00:00Z")); + private static final Instant START_TIME = Instant.parse("2012-03-25T00:00:00Z"); + private final FakeClock clock = new FakeClock(START_TIME); private static final String CREATE_LIMIT_EMAIL_SUBJECT = "create limit subject"; private static final String DOMAIN_LIMIT_WARNING_EMAIL_SUBJECT = "domain limit warning subject"; private static final String DOMAIN_LIMIT_UPGRADE_EMAIL_SUBJECT = "domain limit upgrade subject"; @@ -580,4 +581,172 @@ void testSuccess_multipleBulkPricingPackagesOverActiveDomainsLimit() { tm().transact(() -> BulkPricingPackage.loadByTokenString(token.getToken()).get()); assertThat(packageAfterCheck.getLastNotificationSent().get()).isEqualTo(clock.now()); } + + @Test + void testSuccess_activeDomainOverage_neverNotified_sendsWarningEmail() throws Exception { + bulkPricingPackage = + bulkPricingPackage + .asBuilder() + .setMaxCreates(4) + .setMaxDomains(1) + .setLastNotificationSent(null) + .build(); + tm().transact(() -> tm().put(bulkPricingPackage)); + persistEppResource( + DatabaseHelper.newDomain("foo.tld") + .asBuilder() + .setCurrentBulkToken(token.createVKey()) + .build()); + persistEppResource( + DatabaseHelper.newDomain("buzz.tld") + .asBuilder() + .setCurrentBulkToken(token.createVKey()) + .build()); + + action.run(); + + verify(gmailClient).sendEmail(emailCaptor.capture()); + EmailMessage emailMessage = emailCaptor.getValue(); + assertThat(emailMessage.subject()).isEqualTo(DOMAIN_LIMIT_WARNING_EMAIL_SUBJECT); + assertThat(emailMessage.body()) + .isEqualTo( + String.format(DOMAIN_LIMIT_WARNING_EMAIL_BODY, 1, "abc123", "The Registrar", 1, 2)); + BulkPricingPackage packageAfterCheck = + tm().transact(() -> BulkPricingPackage.loadByTokenString(token.getToken()).get()); + assertThat(packageAfterCheck.getLastNotificationSent()).hasValue(START_TIME); + } + + @Test + void testSuccess_activeDomainOverage_notified29DaysAgo_doesNotSendEmail() { + Instant twentyNineDaysAgo = minusDays(START_TIME, 29); + bulkPricingPackage = + bulkPricingPackage + .asBuilder() + .setMaxCreates(4) + .setMaxDomains(1) + .setLastNotificationSent(twentyNineDaysAgo) + .build(); + tm().transact(() -> tm().put(bulkPricingPackage)); + persistEppResource( + DatabaseHelper.newDomain("foo.tld") + .asBuilder() + .setCurrentBulkToken(token.createVKey()) + .build()); + persistEppResource( + DatabaseHelper.newDomain("buzz.tld") + .asBuilder() + .setCurrentBulkToken(token.createVKey()) + .build()); + + action.run(); + + verifyNoInteractions(gmailClient); + BulkPricingPackage packageAfterCheck = + tm().transact(() -> BulkPricingPackage.loadByTokenString(token.getToken()).get()); + assertThat(packageAfterCheck.getLastNotificationSent()).hasValue(twentyNineDaysAgo); + } + + @Test + void testSuccess_activeDomainOverage_notifiedExactly30DaysAgo_sendsUpgradeEmail() + throws Exception { + bulkPricingPackage = + bulkPricingPackage + .asBuilder() + .setMaxCreates(4) + .setMaxDomains(1) + .setLastNotificationSent(minusDays(START_TIME, 30)) + .build(); + tm().transact(() -> tm().put(bulkPricingPackage)); + persistEppResource( + DatabaseHelper.newDomain("foo.tld") + .asBuilder() + .setCurrentBulkToken(token.createVKey()) + .build()); + persistEppResource( + DatabaseHelper.newDomain("buzz.tld") + .asBuilder() + .setCurrentBulkToken(token.createVKey()) + .build()); + + action.run(); + + verify(gmailClient).sendEmail(emailCaptor.capture()); + EmailMessage emailMessage = emailCaptor.getValue(); + assertThat(emailMessage.subject()).isEqualTo(DOMAIN_LIMIT_UPGRADE_EMAIL_SUBJECT); + assertThat(emailMessage.body()) + .isEqualTo( + String.format(DOMAIN_LIMIT_UPGRADE_EMAIL_BODY, 1, "abc123", "The Registrar", 1, 2)); + BulkPricingPackage packageAfterCheck = + tm().transact(() -> BulkPricingPackage.loadByTokenString(token.getToken()).get()); + assertThat(packageAfterCheck.getLastNotificationSent()).hasValue(START_TIME); + } + + @Test + void testSuccess_activeDomainOverage_notified39DaysAgo_sendsUpgradeEmail() throws Exception { + bulkPricingPackage = + bulkPricingPackage + .asBuilder() + .setMaxCreates(4) + .setMaxDomains(1) + .setLastNotificationSent(minusDays(START_TIME, 39)) + .build(); + tm().transact(() -> tm().put(bulkPricingPackage)); + persistEppResource( + DatabaseHelper.newDomain("foo.tld") + .asBuilder() + .setCurrentBulkToken(token.createVKey()) + .build()); + persistEppResource( + DatabaseHelper.newDomain("buzz.tld") + .asBuilder() + .setCurrentBulkToken(token.createVKey()) + .build()); + + action.run(); + + verify(gmailClient).sendEmail(emailCaptor.capture()); + EmailMessage emailMessage = emailCaptor.getValue(); + assertThat(emailMessage.subject()).isEqualTo(DOMAIN_LIMIT_UPGRADE_EMAIL_SUBJECT); + assertThat(emailMessage.body()) + .isEqualTo( + String.format(DOMAIN_LIMIT_UPGRADE_EMAIL_BODY, 1, "abc123", "The Registrar", 1, 2)); + BulkPricingPackage packageAfterCheck = + tm().transact(() -> BulkPricingPackage.loadByTokenString(token.getToken()).get()); + assertThat(packageAfterCheck.getLastNotificationSent()).hasValue(START_TIME); + } + + @Test + void testSuccess_activeDomainOverage_notifiedExactly40DaysAgo_sendsWarningEmail() + throws Exception { + bulkPricingPackage = + bulkPricingPackage + .asBuilder() + .setMaxCreates(4) + .setMaxDomains(1) + .setLastNotificationSent(minusDays(START_TIME, 40)) + .build(); + tm().transact(() -> tm().put(bulkPricingPackage)); + persistEppResource( + DatabaseHelper.newDomain("foo.tld") + .asBuilder() + .setCurrentBulkToken(token.createVKey()) + .build()); + persistEppResource( + DatabaseHelper.newDomain("buzz.tld") + .asBuilder() + .setCurrentBulkToken(token.createVKey()) + .build()); + + action.run(); + + verify(gmailClient).sendEmail(emailCaptor.capture()); + EmailMessage emailMessage = emailCaptor.getValue(); + assertThat(emailMessage.subject()).isEqualTo(DOMAIN_LIMIT_WARNING_EMAIL_SUBJECT); + assertThat(emailMessage.body()) + .isEqualTo( + String.format(DOMAIN_LIMIT_WARNING_EMAIL_BODY, 1, "abc123", "The Registrar", 1, 2)); + BulkPricingPackage packageAfterCheck = + tm().transact(() -> BulkPricingPackage.loadByTokenString(token.getToken()).get()); + assertThat(packageAfterCheck.getLastNotificationSent()).hasValue(START_TIME); + } }