Remove a couple unnecessary inner transact() calls (#2124)

Also refactors a function to no longer unnecessarily return a low level Iterable
type.

core/src/main/java/google/registry/batch/RelockDomainAction.java

@@ -26,6 +26,7 @@ import com.google.common.collect.ImmutableSet;
 import com.google.common.flogger.FluentLogger;
 import com.google.common.net.MediaType;
 import google.registry.config.RegistryConfig.Config;
+import google.registry.groups.GmailClient;
 import google.registry.model.domain.Domain;
 import google.registry.model.domain.RegistryLock;
 import google.registry.model.eppcommon.StatusValue;
@@ -40,7 +41,6 @@ import google.registry.request.auth.Auth;
 import google.registry.tools.DomainLockUtils;
 import google.registry.util.DateTimeUtils;
 import google.registry.util.EmailMessage;
-import google.registry.util.SendEmailService;
 import java.util.Optional;
 import javax.inject.Inject;
 import javax.mail.internet.AddressException;
@@ -84,7 +84,7 @@ public class RelockDomainAction implements Runnable {
   private final InternetAddress alertRecipientAddress;
   private final InternetAddress gSuiteOutgoingEmailAddress;
   private final String supportEmail;
-  private final SendEmailService sendEmailService;
+  private final GmailClient gmailClient;
   private final DomainLockUtils domainLockUtils;
   private final Response response;
 
@@ -92,10 +92,10 @@ public class RelockDomainAction implements Runnable {
   public RelockDomainAction(
       @Parameter(OLD_UNLOCK_REVISION_ID_PARAM) long oldUnlockRevisionId,
       @Parameter(PREVIOUS_ATTEMPTS_PARAM) int previousAttempts,
-      @Config("alertRecipientEmailAddress") InternetAddress alertRecipientAddress,
+      @Config("newAlertRecipientEmailAddress") InternetAddress alertRecipientAddress,
       @Config("gSuiteOutgoingEmailAddress") InternetAddress gSuiteOutgoingEmailAddress,
       @Config("supportEmail") String supportEmail,
-      SendEmailService sendEmailService,
+      GmailClient gmailClient,
       DomainLockUtils domainLockUtils,
       Response response) {
     this.oldUnlockRevisionId = oldUnlockRevisionId;
@@ -103,7 +103,7 @@ public class RelockDomainAction implements Runnable {
     this.alertRecipientAddress = alertRecipientAddress;
     this.gSuiteOutgoingEmailAddress = gSuiteOutgoingEmailAddress;
     this.supportEmail = supportEmail;
-    this.sendEmailService = sendEmailService;
+    this.gmailClient = gmailClient;
     this.domainLockUtils = domainLockUtils;
     this.response = response;
   }
@@ -215,7 +215,7 @@ public class RelockDomainAction implements Runnable {
             oldLock.getDomainName(),
             t.getMessage(),
             supportEmail);
-    sendEmailService.sendEmail(
+    gmailClient.sendEmail(
         EmailMessage.newBuilder()
             .setFrom(gSuiteOutgoingEmailAddress)
             .setBody(body)
@@ -245,7 +245,7 @@ public class RelockDomainAction implements Runnable {
     String body =
         String.format(RELOCK_SUCCESS_EMAIL_TEMPLATE, oldLock.getDomainName(), supportEmail);
 
-    sendEmailService.sendEmail(
+    gmailClient.sendEmail(
         EmailMessage.newBuilder()
             .setFrom(gSuiteOutgoingEmailAddress)
             .setBody(body)
@@ -264,7 +264,7 @@ public class RelockDomainAction implements Runnable {
             .addAll(getEmailRecipients(oldLock.getRegistrarId()))
             .add(alertRecipientAddress)
             .build();
-    sendEmailService.sendEmail(
+    gmailClient.sendEmail(
         EmailMessage.newBuilder()
             .setFrom(gSuiteOutgoingEmailAddress)
             .setBody(body)
@@ -274,7 +274,7 @@ public class RelockDomainAction implements Runnable {
   }
 
   private void sendUnknownRevisionIdAlertEmail() {
-    sendEmailService.sendEmail(
+    gmailClient.sendEmail(
         EmailMessage.newBuilder()
             .setFrom(gSuiteOutgoingEmailAddress)
             .setBody(String.format(RELOCK_UNKNOWN_ID_FAILURE_EMAIL_TEMPLATE, oldUnlockRevisionId))

core/src/main/java/google/registry/beam/rde/RdeIO.java

@@ -274,10 +274,7 @@ public class RdeIO {
                 PendingDeposit key = input.getKey();
                 Tld tld = Tld.get(key.tld());
                 Optional<Cursor> cursor =
-                    tm().transact(
-                            () ->
-                                tm().loadByKeyIfPresent(
-                                        Cursor.createScopedVKey(key.cursor(), tld)));
+                    tm().loadByKeyIfPresent(Cursor.createScopedVKey(key.cursor(), tld));
                 DateTime position = getCursorTimeOrStartOfTime(cursor);
                 checkState(key.interval() != null, "Interval must be present");
                 DateTime newPosition = key.watermark().plus(key.interval());

core/src/main/java/google/registry/config/files/nomulus-config-unittest.yaml

@@ -28,4 +28,4 @@ misc:
   transientFailureRetries: 3
 
 hibernate:
-  perTransactionIsolation: false
+  perTransactionIsolation: true

core/src/main/java/google/registry/model/registrar/Registrar.java

@@ -19,7 +19,6 @@ import static com.google.common.base.Preconditions.checkArgument;
 import static com.google.common.base.Preconditions.checkNotNull;
 import static com.google.common.base.Strings.emptyToNull;
 import static com.google.common.base.Strings.nullToEmpty;
-import static com.google.common.collect.ImmutableList.toImmutableList;
 import static com.google.common.collect.ImmutableSet.toImmutableSet;
 import static com.google.common.collect.ImmutableSortedSet.toImmutableSortedSet;
 import static com.google.common.collect.Sets.immutableEnumSet;
@@ -49,7 +48,6 @@ import com.google.common.collect.ImmutableSortedSet;
 import com.google.common.collect.Maps;
 import com.google.common.collect.Range;
 import com.google.common.collect.Sets;
-import com.google.common.collect.Streams;
 import com.google.gson.annotations.Expose;
 import com.google.re2j.Pattern;
 import google.registry.model.Buildable;
@@ -556,7 +554,7 @@ public class Registrar extends UpdateAutoTimestampEntity implements Buildable, J
    * address.
    */
   public ImmutableSortedSet<RegistrarPoc> getContacts() {
-    return Streams.stream(getContactsIterable())
+    return getContactPocs().stream()
         .filter(Objects::nonNull)
         .collect(toImmutableSortedSet(CONTACT_EMAIL_COMPARATOR));
   }
@@ -566,7 +564,7 @@ public class Registrar extends UpdateAutoTimestampEntity implements Buildable, J
    * their email address.
    */
   public ImmutableSortedSet<RegistrarPoc> getContactsOfType(final RegistrarPoc.Type type) {
-    return Streams.stream(getContactsIterable())
+    return getContactPocs().stream()
         .filter(Objects::nonNull)
         .filter((@Nullable RegistrarPoc contact) -> contact.getTypes().contains(type))
         .collect(toImmutableSortedSet(CONTACT_EMAIL_COMPARATOR));
@@ -580,13 +578,13 @@ public class Registrar extends UpdateAutoTimestampEntity implements Buildable, J
     return getContacts().stream().filter(RegistrarPoc::getVisibleInDomainWhoisAsAbuse).findFirst();
   }
 
-  private Iterable<RegistrarPoc> getContactsIterable() {
+  private ImmutableSet<RegistrarPoc> getContactPocs() {
     return tm().transact(
             () ->
                 tm().query("FROM RegistrarPoc WHERE registrarId = :registrarId", RegistrarPoc.class)
                     .setParameter("registrarId", registrarId)
                     .getResultStream()
-                    .collect(toImmutableList()));
+                    .collect(toImmutableSet()));
   }
 
   @Override
@@ -732,8 +730,7 @@ public class Registrar extends UpdateAutoTimestampEntity implements Buildable, J
               .map(Tld::createVKey)
               .collect(toImmutableSet());
       Set<VKey<Tld>> missingTldKeys =
-          Sets.difference(
-              newTldKeys, tm().transact(() -> tm().loadByKeysIfPresent(newTldKeys)).keySet());
+          Sets.difference(newTldKeys, tm().loadByKeysIfPresent(newTldKeys).keySet());
       checkArgument(missingTldKeys.isEmpty(), "Trying to set nonexistent TLDs: %s", missingTldKeys);
       getInstance().allowedTlds = ImmutableSortedSet.copyOf(allowedTlds);
       return this;

core/src/main/java/google/registry/module/frontend/FrontendComponent.java

@@ -23,6 +23,7 @@ import google.registry.config.RegistryConfig.ConfigModule;
 import google.registry.flows.ServerTridProviderModule;
 import google.registry.flows.custom.CustomLogicFactoryModule;
 import google.registry.groups.DirectoryModule;
+import google.registry.groups.GmailModule;
 import google.registry.groups.GroupsModule;
 import google.registry.groups.GroupssettingsModule;
 import google.registry.keyring.KeyringModule;
@@ -54,6 +55,7 @@ import javax.inject.Singleton;
       DirectoryModule.class,
       DummyKeyringModule.class,
       FrontendRequestComponentModule.class,
+      GmailModule.class,
       GroupsModule.class,
       GroupssettingsModule.class,
       GsonModule.class,

core/src/main/java/google/registry/persistence/transaction/JpaTransactionManagerImpl.java

@@ -167,12 +167,17 @@ public class JpaTransactionManagerImpl implements JpaTransactionManager {
   public <T> T transactNoRetry(
       Supplier<T> work, @Nullable TransactionIsolationLevel isolationLevel) {
     if (inTransaction()) {
-      if (getHibernatePerTransactionIsolationEnabled()) {
-        throw new IllegalStateException("Nested transaction detected");
-      } else {
-        logger.atWarning().log("Nested transaction detected");
-        return work.get();
+      if (isolationLevel != null && getHibernatePerTransactionIsolationEnabled()) {
+        TransactionIsolationLevel enclosingLevel = getCurrentTransactionIsolationLevel();
+        if (isolationLevel != enclosingLevel) {
+          throw new IllegalStateException(
+              String.format(
+                  "Isolation level conflict detected in nested transactions.\n"
+                      + "Enclosing transaction: %s\nCurrent transaction: %s",
+                  enclosingLevel, isolationLevel));
+        }
       }
+      return work.get();
     }
     TransactionInfo txnInfo = transactionInfo.get();
     txnInfo.entityManager = emf.createEntityManager();

core/src/main/java/google/registry/tools/RegistryToolComponent.java

@@ -114,18 +114,19 @@ interface RegistryToolComponent {
 
   void inject(GenerateEscrowDepositCommand command);
 
+  void inject(GetBulkPricingPackageCommand command);
+
   void inject(GetContactCommand command);
 
   void inject(GetDomainCommand command);
 
   void inject(GetHostCommand command);
-
-  void inject(GetBulkPricingPackageCommand command);
-
   void inject(GetKeyringSecretCommand command);
 
   void inject(GetSqlCredentialCommand command);
 
+  void inject(GetTldCommand command);
+
   void inject(GhostrydeCommand command);
 
   void inject(ListCursorsCommand command);

core/src/main/java/google/registry/ui/server/registrar/RegistryLockPostAction.java

@@ -31,6 +31,7 @@ import com.google.common.flogger.FluentLogger;
 import com.google.gson.Gson;
 import google.registry.config.RegistryConfig.Config;
 import google.registry.flows.domain.DomainFlowUtils;
+import google.registry.groups.GmailClient;
 import google.registry.model.domain.RegistryLock;
 import google.registry.model.registrar.Registrar;
 import google.registry.model.registrar.RegistrarPoc;
@@ -46,7 +47,6 @@ import google.registry.request.auth.UserAuthInfo;
 import google.registry.security.JsonResponseHelper;
 import google.registry.tools.DomainLockUtils;
 import google.registry.util.EmailMessage;
-import google.registry.util.SendEmailService;
 import java.net.URISyntaxException;
 import java.util.Map;
 import java.util.Optional;
@@ -83,7 +83,7 @@ public class RegistryLockPostAction implements Runnable, JsonActionRunner.JsonAc
   private final JsonActionRunner jsonActionRunner;
   private final AuthResult authResult;
   private final AuthenticatedRegistrarAccessor registrarAccessor;
-  private final SendEmailService sendEmailService;
+  private final GmailClient gmailClient;
   private final DomainLockUtils domainLockUtils;
   private final InternetAddress gSuiteOutgoingEmailAddress;
 
@@ -93,14 +93,14 @@ public class RegistryLockPostAction implements Runnable, JsonActionRunner.JsonAc
       JsonActionRunner jsonActionRunner,
       AuthResult authResult,
       AuthenticatedRegistrarAccessor registrarAccessor,
-      SendEmailService sendEmailService,
+      GmailClient gmailClient,
       DomainLockUtils domainLockUtils,
       @Config("gSuiteOutgoingEmailAddress") InternetAddress gSuiteOutgoingEmailAddress) {
     this.req = req;
     this.jsonActionRunner = jsonActionRunner;
     this.authResult = authResult;
     this.registrarAccessor = registrarAccessor;
-    this.sendEmailService = sendEmailService;
+    this.gmailClient = gmailClient;
     this.domainLockUtils = domainLockUtils;
     this.gSuiteOutgoingEmailAddress = gSuiteOutgoingEmailAddress;
   }
@@ -168,7 +168,7 @@ public class RegistryLockPostAction implements Runnable, JsonActionRunner.JsonAc
       ImmutableList<InternetAddress> recipients =
           ImmutableList.of(new InternetAddress(userEmail, true));
       String action = isLock ? "lock" : "unlock";
-      sendEmailService.sendEmail(
+      gmailClient.sendEmail(
           EmailMessage.newBuilder()
               .setBody(body)
               .setSubject(String.format("Registry %s verification", action))

core/src/test/java/google/registry/batch/RelockDomainActionTest.java

@@ -35,6 +35,7 @@ import static org.mockito.Mockito.verifyNoMoreInteractions;
 
 import com.google.cloud.tasks.v2.HttpMethod;
 import com.google.common.collect.ImmutableSet;
+import google.registry.groups.GmailClient;
 import google.registry.model.domain.Domain;
 import google.registry.model.domain.RegistryLock;
 import google.registry.model.host.Host;
@@ -48,7 +49,6 @@ import google.registry.testing.FakeClock;
 import google.registry.testing.FakeResponse;
 import google.registry.tools.DomainLockUtils;
 import google.registry.util.EmailMessage;
-import google.registry.util.SendEmailService;
 import google.registry.util.StringGenerator.Alphabets;
 import java.util.Optional;
 import javax.mail.internet.InternetAddress;
@@ -85,7 +85,7 @@ public class RelockDomainActionTest {
 
   private Domain domain;
   private RegistryLock oldLock;
-  @Mock private SendEmailService sendEmailService;
+  @Mock private GmailClient gmailClient;
   private RelockDomainAction action;
 
   @BeforeEach
@@ -107,7 +107,7 @@ public class RelockDomainActionTest {
 
   @AfterEach
   void afterEach() {
-    verifyNoMoreInteractions(sendEmailService);
+    verifyNoMoreInteractions(gmailClient);
   }
 
   @Test
@@ -260,7 +260,7 @@ public class RelockDomainActionTest {
                 ImmutableSet.of(new InternetAddress("Marla.Singer.RegistryLock@crr.com")))
             .setFrom(new InternetAddress("outgoing@example.com"))
             .build();
-    verify(sendEmailService).sendEmail(expectedEmail);
+    verify(gmailClient).sendEmail(expectedEmail);
   }
 
   private void assertNonTransientFailureEmail(String exceptionMessage) throws Exception {
@@ -294,7 +294,7 @@ public class RelockDomainActionTest {
             .setRecipients(recipients)
             .setFrom(new InternetAddress("outgoing@example.com"))
             .build();
-    verify(sendEmailService).sendEmail(expectedEmail);
+    verify(gmailClient).sendEmail(expectedEmail);
   }
 
   private void assertTaskEnqueued(int numAttempts) {
@@ -328,7 +328,7 @@ public class RelockDomainActionTest {
         alertRecipientAddress,
         gSuiteOutgoingAddress,
         "support@example.com",
-        sendEmailService,
+        gmailClient,
         domainLockUtils,
         response);
   }

core/src/test/java/google/registry/model/registrar/RegistrarTest.java

@@ -507,11 +507,14 @@ class RegistrarTest extends EntityTestCase {
   @Test
   void testSuccess_setAllowedTldsUncached() {
     assertThat(
-            registrar
-                .asBuilder()
-                .setAllowedTldsUncached(ImmutableSet.of("xn--q9jyb4c"))
-                .build()
-                .getAllowedTlds())
+            tm().transact(
+                    () -> {
+                      return registrar
+                          .asBuilder()
+                          .setAllowedTldsUncached(ImmutableSet.of("xn--q9jyb4c"))
+                          .build()
+                          .getAllowedTlds();
+                    }))
         .containsExactly("xn--q9jyb4c");
   }
 
@@ -524,9 +527,12 @@ class RegistrarTest extends EntityTestCase {
 
   @Test
   void testFailure_setAllowedTldsUncached_nonexistentTld() {
-    assertThrows(
-        IllegalArgumentException.class,
-        () -> registrar.asBuilder().setAllowedTldsUncached(ImmutableSet.of("bad")));
+    tm().transact(
+            () -> {
+              assertThrows(
+                  IllegalArgumentException.class,
+                  () -> registrar.asBuilder().setAllowedTldsUncached(ImmutableSet.of("bad")));
+            });
   }
 
   @Test
@@ -614,11 +620,14 @@ class RegistrarTest extends EntityTestCase {
 
       // Test that the uncached version works
       assertThat(
-              registrar
-                  .asBuilder()
-                  .setAllowedTldsUncached(ImmutableSet.of("newtld"))
-                  .build()
-                  .getAllowedTlds())
+              tm().transact(
+                      () -> {
+                        return registrar
+                            .asBuilder()
+                            .setAllowedTldsUncached(ImmutableSet.of("newtld"))
+                            .build()
+                            .getAllowedTlds();
+                      }))
           .containsExactly("newtld");
 
       // Test that the "regular" cached version fails. If this doesn't throw - then we changed how

core/src/test/java/google/registry/persistence/transaction/JpaTransactionManagerImplTest.java

@@ -16,6 +16,7 @@ package google.registry.persistence.transaction;
 
 import static com.google.common.collect.ImmutableList.toImmutableList;
 import static com.google.common.truth.Truth.assertThat;
+import static google.registry.persistence.PersistenceModule.TransactionIsolationLevel.TRANSACTION_READ_COMMITTED;
 import static google.registry.persistence.PersistenceModule.TransactionIsolationLevel.TRANSACTION_READ_UNCOMMITTED;
 import static google.registry.persistence.PersistenceModule.TransactionIsolationLevel.TRANSACTION_REPEATABLE_READ;
 import static google.registry.persistence.transaction.TransactionManagerFactory.tm;
@@ -126,25 +127,122 @@ class JpaTransactionManagerImplTest {
   }
 
   @Test
-  void transact_nestedTransactions() {
-    // Unit tests always allows for per-transaction isolation level (and therefore throws when a
-    // nested transaction is detected).
-    if (RegistryConfig.getHibernatePerTransactionIsolationEnabled()) {
-      IllegalArgumentException e =
-          assertThrows(
-              IllegalArgumentException.class,
-              () ->
-                  tm().transact(
-                          () -> {
-                            tm().transact(() -> {});
-                          }));
-      assertThat(e).hasMessageThat().isEqualTo("Nested transaction detected");
-    } else {
-      tm().transact(
-              () -> {
-                tm().transact(() -> {});
-              });
+  void transact_nestedTransactions_perTransactionIsolationLevelEnabled() {
+    if (!RegistryConfig.getHibernatePerTransactionIsolationEnabled()) {
+      return;
     }
+    // Nested transactions allowed (both at the default isolation level).
+    tm().transact(
+            () -> {
+              tm().assertTransactionIsolationLevel(tm().getDefaultTransactionIsolationLevel());
+              tm().transact(
+                      () -> {
+                        tm().assertTransactionIsolationLevel(
+                                tm().getDefaultTransactionIsolationLevel());
+                      });
+            });
+    // Nested transactions allowed (enclosed transaction does not have an override, using the
+    // enclosing transaction's level).
+    tm().transact(
+            () -> {
+              tm().assertTransactionIsolationLevel(TRANSACTION_READ_UNCOMMITTED);
+              tm().transact(
+                      () -> {
+                        tm().assertTransactionIsolationLevel(TRANSACTION_READ_UNCOMMITTED);
+                      });
+            },
+            TRANSACTION_READ_UNCOMMITTED);
+    // Nested transactions allowed (Both have the same override).
+    tm().transact(
+            () -> {
+              tm().assertTransactionIsolationLevel(TRANSACTION_REPEATABLE_READ);
+              tm().transact(
+                      () -> {
+                        tm().assertTransactionIsolationLevel(TRANSACTION_REPEATABLE_READ);
+                      },
+                      TRANSACTION_REPEATABLE_READ);
+            },
+            TRANSACTION_REPEATABLE_READ);
+    // Nested transactions disallowed (enclosed transaction has an override that conflicts from the
+    // default).
+    IllegalStateException e =
+        assertThrows(
+            IllegalStateException.class,
+            () ->
+                tm().transact(
+                        () -> {
+                          tm().transact(() -> {}, TRANSACTION_READ_COMMITTED);
+                        }));
+    assertThat(e).hasMessageThat().contains("conflict detected");
+    // Nested transactions disallowed (conflicting overrides).
+    e =
+        assertThrows(
+            IllegalStateException.class,
+            () ->
+                tm().transact(
+                        () -> {
+                          tm().transact(() -> {}, TRANSACTION_READ_COMMITTED);
+                        },
+                        TRANSACTION_REPEATABLE_READ));
+    assertThat(e).hasMessageThat().contains("conflict detected");
+  }
+
+  @Test
+  void transact_nestedTransactions_perTransactionIsolationLevelDisabled() {
+    if (RegistryConfig.getHibernatePerTransactionIsolationEnabled()) {
+      return;
+    }
+    tm().transact(
+            () -> {
+              tm().assertTransactionIsolationLevel(tm().getDefaultTransactionIsolationLevel());
+              tm().transact(
+                      () -> {
+                        tm().assertTransactionIsolationLevel(
+                                tm().getDefaultTransactionIsolationLevel());
+                      });
+            });
+    tm().transact(
+            () -> {
+              tm().assertTransactionIsolationLevel(tm().getDefaultTransactionIsolationLevel());
+              tm().transact(
+                      () -> {
+                        tm().assertTransactionIsolationLevel(
+                                tm().getDefaultTransactionIsolationLevel());
+                      });
+            },
+            TRANSACTION_READ_UNCOMMITTED);
+    tm().transact(
+            () -> {
+              tm().assertTransactionIsolationLevel(tm().getDefaultTransactionIsolationLevel());
+              tm().transact(
+                      () -> {
+                        tm().assertTransactionIsolationLevel(
+                                tm().getDefaultTransactionIsolationLevel());
+                      },
+                      TRANSACTION_READ_UNCOMMITTED);
+            });
+    tm().transact(
+            () -> {
+              tm().assertTransactionIsolationLevel(tm().getDefaultTransactionIsolationLevel());
+              tm().transact(
+                      () -> {
+                        tm().assertTransactionIsolationLevel(
+                                tm().getDefaultTransactionIsolationLevel());
+                      },
+                      TRANSACTION_READ_UNCOMMITTED);
+            },
+            TRANSACTION_READ_UNCOMMITTED);
+    tm().transact(
+            () -> {
+              tm().assertTransactionIsolationLevel(tm().getDefaultTransactionIsolationLevel());
+              tm().transact(
+                      () -> {
+                        tm().assertTransactionIsolationLevel(
+                                tm().getDefaultTransactionIsolationLevel());
+                      },
+                      TRANSACTION_READ_COMMITTED);
+            },
+            TRANSACTION_READ_UNCOMMITTED);
   }
 
   @Test

core/src/test/java/google/registry/ui/server/registrar/RegistryLockPostActionTest.java

@@ -33,6 +33,7 @@ import com.google.appengine.api.users.User;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.ImmutableSet;
+import google.registry.groups.GmailClient;
 import google.registry.model.console.RegistrarRole;
 import google.registry.model.console.UserRoles;
 import google.registry.model.domain.Domain;
@@ -54,7 +55,6 @@ import google.registry.testing.DeterministicStringGenerator;
 import google.registry.testing.FakeClock;
 import google.registry.tools.DomainLockUtils;
 import google.registry.util.EmailMessage;
-import google.registry.util.SendEmailService;
 import google.registry.util.StringGenerator.Alphabets;
 import java.util.Map;
 import java.util.Optional;
@@ -97,7 +97,7 @@ final class RegistryLockPostActionTest {
   private Domain domain;
   private RegistryLockPostAction action;
 
-  @Mock SendEmailService emailService;
+  @Mock GmailClient gmailClient;
   @Mock HttpServletRequest mockRequest;
   @Mock HttpServletResponse mockResponse;
 
@@ -510,12 +510,12 @@ final class RegistryLockPostActionTest {
   private void assertFailureWithMessage(Map<String, ?> response, String message) {
     assertThat(response)
         .containsExactly("status", "ERROR", "results", ImmutableList.of(), "message", message);
-    verifyNoMoreInteractions(emailService);
+    verifyNoMoreInteractions(gmailClient);
   }
 
   private void verifyEmail(String recipient) throws Exception {
     ArgumentCaptor<EmailMessage> emailCaptor = ArgumentCaptor.forClass(EmailMessage.class);
-    verify(emailService).sendEmail(emailCaptor.capture());
+    verify(gmailClient).sendEmail(emailCaptor.capture());
     EmailMessage sentMessage = emailCaptor.getValue();
     assertThat(sentMessage.subject()).matches("Registry (un)?lock verification");
     assertThat(sentMessage.body()).matches(EMAIL_MESSAGE_TEMPLATE);
@@ -545,7 +545,7 @@ final class RegistryLockPostActionTest {
         jsonActionRunner,
         authResult,
         registrarAccessor,
-        emailService,
+        gmailClient,
         domainLockUtils,
         outgoingAddress);
   }