Add console action test base case (#2762)

We can probably improve on this in the future if we want, but there's a lot of boilerplate that we don't need to repeat over and over
2026-01-04 04:04:22 +00:00 · 2025-06-04 11:36:22 -04:00
parent 7ec599f849
commit a7696c3fac
16 changed files with 298 additions and 606 deletions
--- a/core/src/test/java/google/registry/ui/server/console/ConsoleActionBaseTestCase.java
+++ b/core/src/test/java/google/registry/ui/server/console/ConsoleActionBaseTestCase.java
@@ -0,0 +1,54 @@
+// Copyright 2025 The Nomulus Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package google.registry.ui.server.console;
+
+import static google.registry.testing.DatabaseHelper.createAdminUser;
+import static google.registry.testing.DatabaseHelper.createTld;
+
+import com.google.gson.Gson;
+import google.registry.model.console.User;
+import google.registry.persistence.transaction.JpaTestExtensions;
+import google.registry.request.auth.AuthResult;
+import google.registry.testing.ConsoleApiParamsUtils;
+import google.registry.testing.FakeClock;
+import google.registry.testing.FakeResponse;
+import google.registry.tools.GsonUtils;
+import org.joda.time.DateTime;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.extension.RegisterExtension;
+
+public abstract class ConsoleActionBaseTestCase {
+
+  protected static final Gson GSON = GsonUtils.provideGson();
+
+  protected final FakeClock clock = new FakeClock(DateTime.parse("2024-04-15T00:00:00.000Z"));
+
+  @RegisterExtension
+  final JpaTestExtensions.JpaIntegrationTestExtension jpa =
+      new JpaTestExtensions.Builder().withClock(clock).buildIntegrationTestExtension();
+
+  protected ConsoleApiParams consoleApiParams;
+  protected FakeResponse response;
+  protected User fteUser;
+
+  @BeforeEach
+  void beforeEachBaseTestCase() {
+    createTld("tld");
+    fteUser = createAdminUser("fte@email.tld");
+    AuthResult authResult = AuthResult.createUser(fteUser);
+    consoleApiParams = ConsoleApiParamsUtils.createFake(authResult);
+    response = (FakeResponse) consoleApiParams.response();
+  }
+}
--- a/core/src/test/java/google/registry/ui/server/console/ConsoleDomainGetActionTest.java
+++ b/core/src/test/java/google/registry/ui/server/console/ConsoleDomainGetActionTest.java
@@ -15,7 +15,6 @@
 package google.registry.ui.server.console;

 import static com.google.common.truth.Truth.assertThat;
-import static google.registry.testing.DatabaseHelper.createTld;
 import static jakarta.servlet.http.HttpServletResponse.SC_NOT_FOUND;
 import static jakarta.servlet.http.HttpServletResponse.SC_OK;
 import static jakarta.servlet.http.HttpServletResponse.SC_UNAUTHORIZED;
@@ -25,7 +24,6 @@ import com.google.common.collect.ImmutableMap;
 import google.registry.model.console.RegistrarRole;
 import google.registry.model.console.User;
 import google.registry.model.console.UserRoles;
-import google.registry.persistence.transaction.JpaTestExtensions;
 import google.registry.request.Action;
 import google.registry.request.auth.AuthResult;
 import google.registry.testing.ConsoleApiParamsUtils;
@@ -33,20 +31,12 @@ import google.registry.testing.DatabaseHelper;
 import google.registry.testing.FakeResponse;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.RegisterExtension;

 /** Tests for {@link google.registry.ui.server.console.ConsoleDomainGetAction}. */
-public class ConsoleDomainGetActionTest {
-
-  private ConsoleApiParams consoleApiParams;
-
-  @RegisterExtension
-  final JpaTestExtensions.JpaIntegrationTestExtension jpa =
-      new JpaTestExtensions.Builder().buildIntegrationTestExtension();
+public class ConsoleDomainGetActionTest extends ConsoleActionBaseTestCase {

  @BeforeEach
  void beforeEach() {
-    createTld("tld");
    DatabaseHelper.persistActiveDomain("exists.tld");
  }

@@ -62,8 +52,8 @@ public class ConsoleDomainGetActionTest {
                        .build())),
            "exists.tld");
    action.run();
-    assertThat(((FakeResponse) consoleApiParams.response()).getStatus()).isEqualTo(SC_OK);
-    assertThat(((FakeResponse) consoleApiParams.response()).getPayload())
+    assertThat(response.getStatus()).isEqualTo(SC_OK);
+    assertThat(response.getPayload())
        .isEqualTo(
            "{\"domainName\":\"exists.tld\",\"adminContact\":{\"key\":\"3-ROID\",\"kind\":"
                + "\"google.registry.model.contact.Contact\"},\"techContact\":{\"key\":\"3-ROID\","
@@ -81,7 +71,7 @@ public class ConsoleDomainGetActionTest {
  void testFailure_emptyAuth() {
    ConsoleDomainGetAction action = createAction(AuthResult.NOT_AUTHENTICATED, "exists.tld");
    action.run();
-    assertThat(((FakeResponse) consoleApiParams.response()).getStatus()).isEqualTo(SC_UNAUTHORIZED);
+    assertThat(response.getStatus()).isEqualTo(SC_UNAUTHORIZED);
  }

  @Test
@@ -89,7 +79,7 @@ public class ConsoleDomainGetActionTest {
    ConsoleDomainGetAction action =
        createAction(AuthResult.createApp("service@registry.example"), "exists.tld");
    action.run();
-    assertThat(((FakeResponse) consoleApiParams.response()).getStatus()).isEqualTo(SC_UNAUTHORIZED);
+    assertThat(response.getStatus()).isEqualTo(SC_UNAUTHORIZED);
  }

  @Test
@@ -98,17 +88,14 @@ public class ConsoleDomainGetActionTest {
        createAction(
            AuthResult.createUser(createUser(new UserRoles.Builder().build())), "exists.tld");
    action.run();
-    assertThat(((FakeResponse) consoleApiParams.response()).getStatus()).isEqualTo(SC_NOT_FOUND);
+    assertThat(response.getStatus()).isEqualTo(SC_NOT_FOUND);
  }

  @Test
  void testFailure_nonexistentDomain() {
-    ConsoleDomainGetAction action =
-        createAction(
-            AuthResult.createUser(createUser(new UserRoles.Builder().setIsAdmin(true).build())),
-            "nonexistent.tld");
+    ConsoleDomainGetAction action = createAction(AuthResult.createUser(fteUser), "nonexistent.tld");
    action.run();
-    assertThat(((FakeResponse) consoleApiParams.response()).getStatus()).isEqualTo(SC_NOT_FOUND);
+    assertThat(response.getStatus()).isEqualTo(SC_NOT_FOUND);
  }

  private User createUser(UserRoles userRoles) {
@@ -120,6 +107,7 @@ public class ConsoleDomainGetActionTest {

  private ConsoleDomainGetAction createAction(AuthResult authResult, String domain) {
    consoleApiParams = ConsoleApiParamsUtils.createFake(authResult);
+    response = (FakeResponse) consoleApiParams.response();
    when(consoleApiParams.request().getMethod()).thenReturn(Action.Method.GET.toString());
    return new ConsoleDomainGetAction(consoleApiParams, domain);
  }
--- a/core/src/test/java/google/registry/ui/server/console/ConsoleDomainListActionTest.java
+++ b/core/src/test/java/google/registry/ui/server/console/ConsoleDomainListActionTest.java
@@ -16,49 +16,31 @@ package google.registry.ui.server.console;

 import static com.google.common.collect.ImmutableList.toImmutableList;
 import static com.google.common.truth.Truth.assertThat;
-import static google.registry.testing.DatabaseHelper.createAdminUser;
-import static google.registry.testing.DatabaseHelper.createTld;
 import static google.registry.testing.DatabaseHelper.persistActiveDomain;
 import static google.registry.testing.DatabaseHelper.persistDomainAsDeleted;
 import static jakarta.servlet.http.HttpServletResponse.SC_BAD_REQUEST;
 import static org.mockito.Mockito.when;

 import com.google.common.collect.Iterables;
-import com.google.gson.Gson;
 import google.registry.model.EppResourceUtils;
 import google.registry.model.domain.Domain;
-import google.registry.persistence.transaction.JpaTestExtensions;
 import google.registry.request.Action;
 import google.registry.request.auth.AuthResult;
 import google.registry.testing.ConsoleApiParamsUtils;
 import google.registry.testing.DatabaseHelper;
-import google.registry.testing.FakeClock;
 import google.registry.testing.FakeResponse;
-import google.registry.tools.GsonUtils;
 import google.registry.ui.server.console.ConsoleDomainListAction.DomainListResult;
 import java.util.Optional;
 import javax.annotation.Nullable;
 import org.joda.time.DateTime;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.RegisterExtension;

 /** Tests for {@link ConsoleDomainListAction}. */
-public class ConsoleDomainListActionTest {
-
-  private static final Gson GSON = GsonUtils.provideGson();
-
-  private final FakeClock clock = new FakeClock(DateTime.parse("2023-10-20T00:00:00.000Z"));
-
-  private ConsoleApiParams consoleApiParams;
-
-  @RegisterExtension
-  final JpaTestExtensions.JpaIntegrationTestExtension jpa =
-      new JpaTestExtensions.Builder().withClock(clock).buildIntegrationTestExtension();
+public class ConsoleDomainListActionTest extends ConsoleActionBaseTestCase {

  @BeforeEach
  void beforeEach() {
-    createTld("tld");
    for (int i = 0; i < 10; i++) {
      DatabaseHelper.persistActiveDomain(i + "exists.tld", clock.nowUtc());
      clock.advanceOneMilli();
@@ -70,9 +52,7 @@ public class ConsoleDomainListActionTest {
  void testSuccess_allDomains() {
    ConsoleDomainListAction action = createAction("TheRegistrar");
    action.run();
-    DomainListResult result =
-        GSON.fromJson(
-            ((FakeResponse) consoleApiParams.response()).getPayload(), DomainListResult.class);
+    DomainListResult result = GSON.fromJson(response.getPayload(), DomainListResult.class);
    assertThat(result.domains).hasSize(10);
    assertThat(result.totalResults).isEqualTo(10);
    assertThat(result.checkpointTime).isEqualTo(clock.nowUtc());
@@ -84,9 +64,7 @@ public class ConsoleDomainListActionTest {
  void testSuccess_noDomains() {
    ConsoleDomainListAction action = createAction("NewRegistrar");
    action.run();
-    DomainListResult result =
-        GSON.fromJson(
-            ((FakeResponse) consoleApiParams.response()).getPayload(), DomainListResult.class);
+    DomainListResult result = GSON.fromJson(response.getPayload(), DomainListResult.class);
    assertThat(result.domains).hasSize(0);
    assertThat(result.totalResults).isEqualTo(0);
    assertThat(result.checkpointTime).isEqualTo(clock.nowUtc());
@@ -97,9 +75,7 @@ public class ConsoleDomainListActionTest {
    // Two pages of results should go in reverse chronological order
    ConsoleDomainListAction action = createAction("TheRegistrar", null, 0, 5, null, null);
    action.run();
-    DomainListResult result =
-        GSON.fromJson(
-            ((FakeResponse) consoleApiParams.response()).getPayload(), DomainListResult.class);
+    DomainListResult result = GSON.fromJson(response.getPayload(), DomainListResult.class);
    assertThat(result.domains.stream().map(Domain::getDomainName).collect(toImmutableList()))
        .containsExactly("9exists.tld", "8exists.tld", "7exists.tld", "6exists.tld", "5exists.tld");
    assertThat(result.totalResults).isEqualTo(10);
@@ -107,9 +83,7 @@ public class ConsoleDomainListActionTest {
    // Now do the second page
    action = createAction("TheRegistrar", result.checkpointTime, 1, 5, 10L, null);
    action.run();
-    result =
-        GSON.fromJson(
-            ((FakeResponse) consoleApiParams.response()).getPayload(), DomainListResult.class);
+    result = GSON.fromJson(response.getPayload(), DomainListResult.class);
    assertThat(result.domains.stream().map(Domain::getDomainName).collect(toImmutableList()))
        .containsExactly("4exists.tld", "3exists.tld", "2exists.tld", "1exists.tld", "0exists.tld");
  }
@@ -118,9 +92,7 @@ public class ConsoleDomainListActionTest {
  void testSuccess_partialPage() {
    ConsoleDomainListAction action = createAction("TheRegistrar", null, 1, 8, null, null);
    action.run();
-    DomainListResult result =
-        GSON.fromJson(
-            ((FakeResponse) consoleApiParams.response()).getPayload(), DomainListResult.class);
+    DomainListResult result = GSON.fromJson(response.getPayload(), DomainListResult.class);
    assertThat(result.domains.stream().map(Domain::getDomainName).collect(toImmutableList()))
        .containsExactly("1exists.tld", "0exists.tld");
  }
@@ -130,9 +102,7 @@ public class ConsoleDomainListActionTest {
    ConsoleDomainListAction action = createAction("TheRegistrar", null, 0, 10, null, null);
    action.run();

-    DomainListResult result =
-        GSON.fromJson(
-            ((FakeResponse) consoleApiParams.response()).getPayload(), DomainListResult.class);
+    DomainListResult result = GSON.fromJson(response.getPayload(), DomainListResult.class);
    assertThat(result.domains).hasSize(10);
    assertThat(result.totalResults).isEqualTo(10);

@@ -142,9 +112,7 @@ public class ConsoleDomainListActionTest {
    // Even though we persisted a new domain, the old checkpoint should return no more results
    action = createAction("TheRegistrar", result.checkpointTime, 1, 10, null, null);
    action.run();
-    result =
-        GSON.fromJson(
-            ((FakeResponse) consoleApiParams.response()).getPayload(), DomainListResult.class);
+    result = GSON.fromJson(response.getPayload(), DomainListResult.class);
    assertThat(result.domains).isEmpty();
    assertThat(result.totalResults).isEqualTo(10);
  }
@@ -153,9 +121,7 @@ public class ConsoleDomainListActionTest {
  void testSuccess_checkpointTime_deletion() {
    ConsoleDomainListAction action = createAction("TheRegistrar", null, 0, 5, null, null);
    action.run();
-    DomainListResult result =
-        GSON.fromJson(
-            ((FakeResponse) consoleApiParams.response()).getPayload(), DomainListResult.class);
+    DomainListResult result = GSON.fromJson(response.getPayload(), DomainListResult.class);

    clock.advanceOneMilli();
    Domain toDelete =
@@ -165,9 +131,7 @@ public class ConsoleDomainListActionTest {
    // Second page should include the domain that is now deleted due to the checkpoint time
    action = createAction("TheRegistrar", result.checkpointTime, 1, 5, null, null);
    action.run();
-    result =
-        GSON.fromJson(
-            ((FakeResponse) consoleApiParams.response()).getPayload(), DomainListResult.class);
+    result = GSON.fromJson(response.getPayload(), DomainListResult.class);
    assertThat(result.domains.stream().map(Domain::getDomainName).collect(toImmutableList()))
        .containsExactly("4exists.tld", "3exists.tld", "2exists.tld", "1exists.tld", "0exists.tld");
  }
@@ -176,9 +140,7 @@ public class ConsoleDomainListActionTest {
  void testSuccess_searchTerm_oneMatch() {
    ConsoleDomainListAction action = createAction("TheRegistrar", null, 0, 5, null, "0");
    action.run();
-    DomainListResult result =
-        GSON.fromJson(
-            ((FakeResponse) consoleApiParams.response()).getPayload(), DomainListResult.class);
+    DomainListResult result = GSON.fromJson(response.getPayload(), DomainListResult.class);
    assertThat(Iterables.getOnlyElement(result.domains).getDomainName()).isEqualTo("0exists.tld");
  }

@@ -186,9 +148,7 @@ public class ConsoleDomainListActionTest {
  void testSuccess_searchTerm_returnsNone() {
    ConsoleDomainListAction action = createAction("TheRegistrar", null, 0, 5, null, "deleted");
    action.run();
-    DomainListResult result =
-        GSON.fromJson(
-            ((FakeResponse) consoleApiParams.response()).getPayload(), DomainListResult.class);
+    DomainListResult result = GSON.fromJson(response.getPayload(), DomainListResult.class);
    assertThat(result.domains).isEmpty();
  }

@@ -196,9 +156,7 @@ public class ConsoleDomainListActionTest {
  void testSuccess_searchTerm_caseInsensitive() {
    ConsoleDomainListAction action = createAction("TheRegistrar", null, 0, 5, null, "eXiStS");
    action.run();
-    DomainListResult result =
-        GSON.fromJson(
-            ((FakeResponse) consoleApiParams.response()).getPayload(), DomainListResult.class);
+    DomainListResult result = GSON.fromJson(response.getPayload(), DomainListResult.class);
    assertThat(result.domains).hasSize(5);
    assertThat(result.totalResults).isEqualTo(10);
  }
@@ -207,9 +165,7 @@ public class ConsoleDomainListActionTest {
  void testSuccess_searchTerm_tld() {
    ConsoleDomainListAction action = createAction("TheRegistrar", null, 0, 5, null, "tld");
    action.run();
-    DomainListResult result =
-        GSON.fromJson(
-            ((FakeResponse) consoleApiParams.response()).getPayload(), DomainListResult.class);
+    DomainListResult result = GSON.fromJson(response.getPayload(), DomainListResult.class);
    assertThat(result.domains).hasSize(5);
    assertThat(result.totalResults).isEqualTo(10);
  }
@@ -218,9 +174,7 @@ public class ConsoleDomainListActionTest {
  void testPartialSuccess_pastEnd() {
    ConsoleDomainListAction action = createAction("TheRegistrar", null, 5, 5, null, null);
    action.run();
-    DomainListResult result =
-        GSON.fromJson(
-            ((FakeResponse) consoleApiParams.response()).getPayload(), DomainListResult.class);
+    DomainListResult result = GSON.fromJson(response.getPayload(), DomainListResult.class);
    assertThat(result.domains).isEmpty();
  }

@@ -228,14 +182,14 @@ public class ConsoleDomainListActionTest {
  void testFailure_invalidResultsPerPage() {
    ConsoleDomainListAction action = createAction("TheRegistrar", null, 0, 0, null, null);
    action.run();
-    assertThat(((FakeResponse) consoleApiParams.response()).getStatus()).isEqualTo(SC_BAD_REQUEST);
-    assertThat(((FakeResponse) consoleApiParams.response()).getPayload())
+    assertThat(response.getStatus()).isEqualTo(SC_BAD_REQUEST);
+    assertThat(response.getPayload())
        .isEqualTo("Results per page must be between 1 and 500 inclusive");

    action = createAction("TheRegistrar", null, 0, 501, null, null);
    action.run();
-    assertThat(((FakeResponse) consoleApiParams.response()).getStatus()).isEqualTo(SC_BAD_REQUEST);
-    assertThat(((FakeResponse) consoleApiParams.response()).getPayload())
+    assertThat(response.getStatus()).isEqualTo(SC_BAD_REQUEST);
+    assertThat(response.getPayload())
        .isEqualTo("Results per page must be between 1 and 500 inclusive");
  }

@@ -243,9 +197,8 @@ public class ConsoleDomainListActionTest {
  void testFailure_invalidPageNumber() {
    ConsoleDomainListAction action = createAction("TheRegistrar", null, -1, 10, null, null);
    action.run();
-    assertThat(((FakeResponse) consoleApiParams.response()).getStatus()).isEqualTo(SC_BAD_REQUEST);
-    assertThat(((FakeResponse) consoleApiParams.response()).getPayload())
-        .isEqualTo("Page number must be non-negative");
+    assertThat(response.getStatus()).isEqualTo(SC_BAD_REQUEST);
+    assertThat(response.getPayload()).isEqualTo("Page number must be non-negative");
  }

  private ConsoleDomainListAction createAction(String registrarId) {
@@ -259,9 +212,10 @@ public class ConsoleDomainListActionTest {
      @Nullable Integer resultsPerPage,
      @Nullable Long totalResults,
      @Nullable String searchTerm) {
-    AuthResult authResult = AuthResult.createUser(createAdminUser("email@email.example"));
+    AuthResult authResult = AuthResult.createUser(fteUser);
    consoleApiParams = ConsoleApiParamsUtils.createFake(authResult);
    when(consoleApiParams.request().getMethod()).thenReturn(Action.Method.GET.toString());
+    response = (FakeResponse) consoleApiParams.response();
    return new ConsoleDomainListAction(
        consoleApiParams,
        registrarId,
--- a/core/src/test/java/google/registry/ui/server/console/ConsoleDumDownloadActionTest.java
+++ b/core/src/test/java/google/registry/ui/server/console/ConsoleDumDownloadActionTest.java
@@ -15,7 +15,6 @@
 package google.registry.ui.server.console;

 import static com.google.common.truth.Truth.assertThat;
-import static google.registry.testing.DatabaseHelper.createTld;
 import static jakarta.servlet.http.HttpServletResponse.SC_FORBIDDEN;
 import static jakarta.servlet.http.HttpServletResponse.SC_OK;
 import static org.mockito.Mockito.when;
@@ -24,32 +23,19 @@ import com.google.common.collect.ImmutableList;
 import google.registry.model.console.GlobalRole;
 import google.registry.model.console.User;
 import google.registry.model.console.UserRoles;
-import google.registry.persistence.transaction.JpaTestExtensions;
 import google.registry.request.Action;
 import google.registry.request.auth.AuthResult;
 import google.registry.testing.ConsoleApiParamsUtils;
 import google.registry.testing.DatabaseHelper;
-import google.registry.testing.FakeClock;
 import google.registry.testing.FakeResponse;
 import java.io.IOException;
-import org.joda.time.DateTime;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.RegisterExtension;

-class ConsoleDumDownloadActionTest {
-
-  private final FakeClock clock = new FakeClock(DateTime.parse("2024-04-15T00:00:00.000Z"));
-
-  private ConsoleApiParams consoleApiParams;
-
-  @RegisterExtension
-  final JpaTestExtensions.JpaIntegrationTestExtension jpa =
-      new JpaTestExtensions.Builder().withClock(clock).buildIntegrationTestExtension();
+class ConsoleDumDownloadActionTest extends ConsoleActionBaseTestCase {

  @BeforeEach
  void beforeEach() {
-    createTld("tld");
    for (int i = 0; i < 3; i++) {
      DatabaseHelper.persistActiveDomain(
          i + "exists.tld", clock.nowUtc(), clock.nowUtc().plusDays(300));
@@ -60,13 +46,7 @@ class ConsoleDumDownloadActionTest {

  @Test
  void testSuccess_returnsCorrectDomains() throws IOException {
-    User user =
-        new User.Builder()
-            .setEmailAddress("email@email.com")
-            .setUserRoles(new UserRoles.Builder().setGlobalRole(GlobalRole.FTE).build())
-            .build();
-
-    AuthResult authResult = AuthResult.createUser(user);
+    AuthResult authResult = AuthResult.createUser(fteUser);
    ConsoleDumDownloadAction action = createAction(authResult);
    action.run();
    ImmutableList<String> expected =
@@ -75,7 +55,6 @@ class ConsoleDumDownloadActionTest {
            "2exists.tld,2024-04-15 00:00:00.002+00,2025-02-09 00:00:00.002+00,{INACTIVE}",
            "1exists.tld,2024-04-15 00:00:00.001+00,2025-02-09 00:00:00.001+00,{INACTIVE}",
            "0exists.tld,2024-04-15 00:00:00+00,2025-02-09 00:00:00+00,{INACTIVE}");
-    FakeResponse response = (FakeResponse) consoleApiParams.response();
    assertThat(response.getStatus()).isEqualTo(SC_OK);
    ImmutableList<String> actual =
        ImmutableList.copyOf(response.getStringWriter().toString().split("\r\n"));
@@ -93,11 +72,12 @@ class ConsoleDumDownloadActionTest {
    AuthResult authResult = AuthResult.createUser(user);
    ConsoleDumDownloadAction action = createAction(authResult);
    action.run();
-    assertThat(((FakeResponse) consoleApiParams.response()).getStatus()).isEqualTo(SC_FORBIDDEN);
+    assertThat(response.getStatus()).isEqualTo(SC_FORBIDDEN);
  }

  private ConsoleDumDownloadAction createAction(AuthResult authResult) {
    consoleApiParams = ConsoleApiParamsUtils.createFake(authResult);
+    response = (FakeResponse) consoleApiParams.response();
    when(consoleApiParams.request().getMethod()).thenReturn(Action.Method.GET.toString());
    return new ConsoleDumDownloadAction(clock, consoleApiParams, "TheRegistrar", "test_name");
  }
--- a/core/src/test/java/google/registry/ui/server/console/ConsoleEppPasswordActionTest.java
+++ b/core/src/test/java/google/registry/ui/server/console/ConsoleEppPasswordActionTest.java
@@ -30,22 +30,12 @@ import static org.mockito.Mockito.when;

 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableSetMultimap;
-import com.google.gson.Gson;
 import google.registry.flows.PasswordOnlyTransportCredentials;
 import google.registry.model.console.ConsoleUpdateHistory;
-import google.registry.model.console.GlobalRole;
-import google.registry.model.console.User;
-import google.registry.model.console.UserRoles;
 import google.registry.model.registrar.Registrar;
-import google.registry.persistence.transaction.JpaTestExtensions;
 import google.registry.request.Action;
 import google.registry.request.RequestModule;
-import google.registry.request.auth.AuthResult;
 import google.registry.request.auth.AuthenticatedRegistrarAccessor;
-import google.registry.testing.ConsoleApiParamsUtils;
-import google.registry.testing.DatabaseHelper;
-import google.registry.testing.FakeResponse;
-import google.registry.tools.GsonUtils;
 import google.registry.ui.server.console.ConsoleEppPasswordAction.EppPasswordData;
 import google.registry.util.EmailMessage;
 import jakarta.mail.internet.AddressException;
@@ -56,20 +46,12 @@ import java.io.StringReader;
 import java.util.Optional;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.RegisterExtension;

-class ConsoleEppPasswordActionTest {
-  private static final Gson GSON = GsonUtils.provideGson();
+class ConsoleEppPasswordActionTest extends ConsoleActionBaseTestCase {
  private static String eppPostData =
      "{\"registrarId\":\"%s\",\"oldPassword\":\"%s\",\"newPassword\":\"%s\",\"newPasswordRepeat\":\"%s\"}";

-  private ConsoleApiParams consoleApiParams;
  protected PasswordOnlyTransportCredentials credentials = new PasswordOnlyTransportCredentials();
-  private FakeResponse response;
-
-  @RegisterExtension
-  final JpaTestExtensions.JpaIntegrationTestExtension jpa =
-      new JpaTestExtensions.Builder().buildIntegrationTestExtension();

  @BeforeEach
  void beforeEach() {
@@ -86,9 +68,8 @@ class ConsoleEppPasswordActionTest {
  void testFailure_emptyParams() throws IOException {
    ConsoleEppPasswordAction action = createAction("", "", "", "");
    action.run();
-    assertThat(((FakeResponse) consoleApiParams.response()).getStatus()).isEqualTo(SC_BAD_REQUEST);
-    assertThat(((FakeResponse) consoleApiParams.response()).getPayload())
-        .isEqualTo("Missing param(s): registrarId");
+    assertThat(response.getStatus()).isEqualTo(SC_BAD_REQUEST);
+    assertThat(response.getPayload()).isEqualTo("Missing param(s): registrarId");
  }

  @Test
@@ -96,9 +77,8 @@ class ConsoleEppPasswordActionTest {
    ConsoleEppPasswordAction action =
        createAction("TheRegistrar", "oldPassword", "newPassword", "newPasswordRepeat");
    action.run();
-    assertThat(((FakeResponse) consoleApiParams.response()).getStatus()).isEqualTo(SC_BAD_REQUEST);
-    assertThat(((FakeResponse) consoleApiParams.response()).getPayload())
-        .contains("New password fields don't match");
+    assertThat(response.getStatus()).isEqualTo(SC_BAD_REQUEST);
+    assertThat(response.getPayload()).contains("New password fields don't match");
  }

  @Test
@@ -106,9 +86,8 @@ class ConsoleEppPasswordActionTest {
    ConsoleEppPasswordAction action =
        createAction("TheRegistrar", "oldPassword", "randomPasword", "randomPasword");
    action.run();
-    assertThat(((FakeResponse) consoleApiParams.response()).getStatus()).isEqualTo(SC_FORBIDDEN);
-    assertThat(((FakeResponse) consoleApiParams.response()).getPayload())
-        .contains("Registrar password is incorrect");
+    assertThat(response.getStatus()).isEqualTo(SC_FORBIDDEN);
+    assertThat(response.getPayload()).contains("Registrar password is incorrect");
  }

  @Test
@@ -124,12 +103,12 @@ class ConsoleEppPasswordActionTest {
                        + " environment")
                .setBody(
                    "The following changes were made in registry unittest environment to the"
-                        + " registrar TheRegistrar by user email@email.com:\n"
+                        + " registrar TheRegistrar by admin fte@email.tld:\n"
                        + "\n"
                        + "password: ******** -> ••••••••\n")
                .setRecipients(ImmutableList.of(new InternetAddress("notification@test.example")))
                .build());
-    assertThat(((FakeResponse) consoleApiParams.response()).getStatus()).isEqualTo(SC_OK);
+    assertThat(response.getStatus()).isEqualTo(SC_OK);
  }

  @Test
@@ -137,7 +116,7 @@ class ConsoleEppPasswordActionTest {
    ConsoleEppPasswordAction action =
        createAction("TheRegistrar", "foobar", "randomPassword", "randomPassword");
    action.run();
-    assertThat(((FakeResponse) consoleApiParams.response()).getStatus()).isEqualTo(SC_OK);
+    assertThat(response.getStatus()).isEqualTo(SC_OK);
    assertDoesNotThrow(() -> credentials.validate(loadRegistrar("TheRegistrar"), "randomPassword"));
    ConsoleUpdateHistory history = loadSingleton(ConsoleUpdateHistory.class).get();
    assertThat(history.getType()).isEqualTo(ConsoleUpdateHistory.Type.EPP_PASSWORD_UPDATE);
@@ -147,16 +126,6 @@ class ConsoleEppPasswordActionTest {
  private ConsoleEppPasswordAction createAction(
      String registrarId, String oldPassword, String newPassword, String newPasswordRepeat)
      throws IOException {
-    response = new FakeResponse();
-    User user =
-        new User.Builder()
-            .setEmailAddress("email@email.com")
-            .setUserRoles(new UserRoles.Builder().setGlobalRole(GlobalRole.FTE).build())
-            .build();
-    DatabaseHelper.putInDb(user);
-
-    AuthResult authResult = AuthResult.createUser(user);
-    consoleApiParams = ConsoleApiParamsUtils.createFake(authResult);
    AuthenticatedRegistrarAccessor authenticatedRegistrarAccessor =
        AuthenticatedRegistrarAccessor.createForTesting(
            ImmutableSetMultimap.of("TheRegistrar", OWNER));
--- a/core/src/test/java/google/registry/ui/server/console/ConsoleOteActionTest.java
+++ b/core/src/test/java/google/registry/ui/server/console/ConsoleOteActionTest.java
@@ -27,19 +27,16 @@ import static org.mockito.Mockito.when;

 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
-import com.google.gson.Gson;
 import google.registry.model.OteStatsTestHelper;
 import google.registry.model.console.GlobalRole;
 import google.registry.model.console.User;
 import google.registry.model.console.UserRoles;
-import google.registry.persistence.transaction.JpaTestExtensions;
 import google.registry.request.Action;
 import google.registry.request.auth.AuthResult;
 import google.registry.testing.CloudTasksHelper;
 import google.registry.testing.ConsoleApiParamsUtils;
 import google.registry.testing.DeterministicStringGenerator;
 import google.registry.testing.FakeResponse;
-import google.registry.tools.GsonUtils;
 import google.registry.tools.IamClient;
 import google.registry.ui.server.console.ConsoleOteAction.OteCreateData;
 import google.registry.util.StringGenerator;
@@ -50,19 +47,11 @@ import java.util.stream.Collectors;
 import org.json.simple.JSONArray;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.RegisterExtension;

-class ConsoleOteActionTest {
+class ConsoleOteActionTest extends ConsoleActionBaseTestCase {

-  @RegisterExtension
-  final JpaTestExtensions.JpaIntegrationTestExtension jpa =
-      new JpaTestExtensions.Builder().buildIntegrationTestExtension();
-
-  private static final Gson GSON = GsonUtils.provideGson();
  private final IamClient iamClient = mock(IamClient.class);
  private final CloudTasksHelper cloudTasksHelper = new CloudTasksHelper();
-  private FakeResponse response;
-  private ConsoleApiParams consoleApiParams;

  private StringGenerator passwordGenerator =
      new DeterministicStringGenerator("abcdefghijklmnopqrstuvwxyz");
@@ -90,16 +79,12 @@ class ConsoleOteActionTest {
            Optional.of("someRandomString"),
            Optional.of(new OteCreateData("testRegistrarId", "tescontact@registry.example")));
    action.run();
-    assertThat(((FakeResponse) consoleApiParams.response()).getStatus()).isEqualTo(SC_FORBIDDEN);
+    assertThat(response.getStatus()).isEqualTo(SC_FORBIDDEN);
  }

  @Test
  void testFailure_invalidParamsNoRegistrarId() {
-    user =
-        user.asBuilder()
-            .setUserRoles(new UserRoles.Builder().setGlobalRole(GlobalRole.FTE).build())
-            .build();
-    AuthResult authResult = AuthResult.createUser(user);
+    AuthResult authResult = AuthResult.createUser(fteUser);
    consoleApiParams = ConsoleApiParamsUtils.createFake(authResult);
    ConsoleOteAction action =
        createAction(
@@ -109,9 +94,8 @@ class ConsoleOteActionTest {
            Optional.of("someRandomString"),
            Optional.of(new OteCreateData("", "test@email.com")));
    action.run();
-    assertThat(((FakeResponse) consoleApiParams.response()).getStatus()).isEqualTo(SC_BAD_REQUEST);
-    assertThat(((FakeResponse) consoleApiParams.response()).getPayload())
-        .isEqualTo("OT&E create body is invalid");
+    assertThat(response.getStatus()).isEqualTo(SC_BAD_REQUEST);
+    assertThat(response.getPayload()).isEqualTo("OT&E create body is invalid");
  }

  @Test
@@ -130,18 +114,13 @@ class ConsoleOteActionTest {
            Optional.of("someRandomString"),
            Optional.of(new OteCreateData("testRegistrarId", "")));
    action.run();
-    assertThat(((FakeResponse) consoleApiParams.response()).getStatus()).isEqualTo(SC_BAD_REQUEST);
-    assertThat(((FakeResponse) consoleApiParams.response()).getPayload())
-        .isEqualTo("OT&E create body is invalid");
+    assertThat(response.getStatus()).isEqualTo(SC_BAD_REQUEST);
+    assertThat(response.getPayload()).isEqualTo("OT&E create body is invalid");
  }

  @Test
  void testSuccess_oteCreated() {
-    user =
-        user.asBuilder()
-            .setUserRoles(new UserRoles.Builder().setGlobalRole(GlobalRole.FTE).build())
-            .build();
-    AuthResult authResult = AuthResult.createUser(user);
+    AuthResult authResult = AuthResult.createUser(fteUser);
    consoleApiParams = ConsoleApiParamsUtils.createFake(authResult);
    ConsoleOteAction action =
        createAction(
@@ -152,8 +131,7 @@ class ConsoleOteActionTest {
            Optional.of(new OteCreateData("theregistrar", "contact@registry.example")));
    action.cloudTasksUtils = cloudTasksHelper.getTestCloudTasksUtils();
    action.run();
-    String response = ((FakeResponse) consoleApiParams.response()).getPayload();
-    var obsResponse = GSON.fromJson(response, Map.class);
+    var obsResponse = GSON.fromJson(response.getPayload(), Map.class);
    assertThat(
            ImmutableMap.of(
                "theregistrar-1", "theregistrar-sunrise",
@@ -162,7 +140,7 @@ class ConsoleOteActionTest {
                "theregistrar-5", "theregistrar-eap",
                "password", "abcdefghijklmnop"))
        .containsExactlyEntriesIn(obsResponse);
-    assertThat(((FakeResponse) consoleApiParams.response()).getStatus()).isEqualTo(SC_OK);
+    assertThat(response.getStatus()).isEqualTo(SC_OK);
    verifyIapPermission(
        "contact@registry.example",
        Optional.of("someRandomString@email.test"),
@@ -183,50 +161,40 @@ class ConsoleOteActionTest {
            Optional.of(new OteCreateData("theregistrar", "contact@registry.example")));
    action.cloudTasksUtils = cloudTasksHelper.getTestCloudTasksUtils();
    action.run();
-    assertThat(((FakeResponse) consoleApiParams.response()).getStatus()).isEqualTo(SC_BAD_REQUEST);
-    assertThat(((FakeResponse) consoleApiParams.response()).getPayload())
-        .isEqualTo("Missing registrarId parameter");
+    assertThat(response.getStatus()).isEqualTo(SC_BAD_REQUEST);
+    assertThat(response.getPayload()).isEqualTo("Missing registrarId parameter");
  }

  @Test
  void testSuccess_finishedOte() throws Exception {
    OteStatsTestHelper.setupCompleteOte("theregistrar");
-    user =
-        user.asBuilder()
-            .setUserRoles(new UserRoles.Builder().setGlobalRole(GlobalRole.FTE).build())
-            .build();
-    AuthResult authResult = AuthResult.createUser(user);
+    AuthResult authResult = AuthResult.createUser(fteUser);
    consoleApiParams = ConsoleApiParamsUtils.createFake(authResult);
    ConsoleOteAction action =
        createAction(
            Action.Method.GET, authResult, "theregistrar-1", Optional.empty(), Optional.empty());
    action.run();

-    List<Map<String, ?>> response =
-        GSON.fromJson(((FakeResponse) consoleApiParams.response()).getPayload(), JSONArray.class);
-    assertThat(((FakeResponse) consoleApiParams.response()).getStatus()).isEqualTo(SC_OK);
-    assertTrue(response.stream().allMatch(status -> Boolean.TRUE.equals(status.get("completed"))));
+    List<Map<String, ?>> responseMaps = GSON.fromJson(response.getPayload(), JSONArray.class);
+    assertThat(response.getStatus()).isEqualTo(SC_OK);
+    assertTrue(
+        responseMaps.stream().allMatch(status -> Boolean.TRUE.equals(status.get("completed"))));
  }

  @Test
  void testSuccess_unfinishedOte() throws Exception {
    OteStatsTestHelper.setupIncompleteOte("theregistrar");
-    user =
-        user.asBuilder()
-            .setUserRoles(new UserRoles.Builder().setGlobalRole(GlobalRole.FTE).build())
-            .build();
-    AuthResult authResult = AuthResult.createUser(user);
+    AuthResult authResult = AuthResult.createUser(fteUser);
    consoleApiParams = ConsoleApiParamsUtils.createFake(authResult);
    ConsoleOteAction action =
        createAction(
            Action.Method.GET, authResult, "theregistrar-1", Optional.empty(), Optional.empty());
    action.run();

-    List<Map<String, ?>> response =
-        GSON.fromJson(((FakeResponse) consoleApiParams.response()).getPayload(), JSONArray.class);
-    assertThat(((FakeResponse) consoleApiParams.response()).getStatus()).isEqualTo(SC_OK);
+    List<Map<String, ?>> responseMaps = GSON.fromJson(response.getPayload(), JSONArray.class);
+    assertThat(response.getStatus()).isEqualTo(SC_OK);
    assertThat(
-            response.stream()
+            responseMaps.stream()
                .filter(status -> Boolean.FALSE.equals(status.get("completed")))
                .map(status -> status.get("description"))
                .collect(Collectors.toList()))
@@ -240,9 +208,9 @@ class ConsoleOteActionTest {
      String registrarId,
      Optional<String> maybeGroupEmailAddress,
      Optional<OteCreateData> oteCreateData) {
-    response = new FakeResponse();
    consoleApiParams = ConsoleApiParamsUtils.createFake(authResult);
    when(consoleApiParams.request().getMethod()).thenReturn(method.toString());
+    response = (FakeResponse) consoleApiParams.response();
    return new ConsoleOteAction(
        consoleApiParams,
        iamClient,
--- a/core/src/test/java/google/registry/ui/server/console/ConsoleRegistryLockActionTest.java
+++ b/core/src/test/java/google/registry/ui/server/console/ConsoleRegistryLockActionTest.java
@@ -42,12 +42,10 @@ import google.registry.model.console.UserRoles;
 import google.registry.model.domain.Domain;
 import google.registry.model.domain.RegistryLock;
 import google.registry.model.eppcommon.StatusValue;
-import google.registry.persistence.transaction.JpaTestExtensions;
 import google.registry.request.auth.AuthResult;
 import google.registry.testing.CloudTasksHelper;
 import google.registry.testing.ConsoleApiParamsUtils;
 import google.registry.testing.DeterministicStringGenerator;
-import google.registry.testing.FakeClock;
 import google.registry.testing.FakeResponse;
 import google.registry.tools.DomainLockUtils;
 import google.registry.util.EmailMessage;
@@ -55,13 +53,11 @@ import google.registry.util.StringGenerator;
 import jakarta.mail.internet.InternetAddress;
 import java.io.IOException;
 import java.util.Optional;
-import org.joda.time.DateTime;
 import org.joda.time.Duration;
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
-import org.junit.jupiter.api.extension.RegisterExtension;
 import org.mockito.ArgumentCaptor;
 import org.mockito.Mock;
 import org.mockito.junit.jupiter.MockitoExtension;
@@ -71,7 +67,7 @@ import org.mockito.quality.Strictness;
 /** Tests for {@link ConsoleRegistryLockAction}. */
@ExtendWith(MockitoExtension.class)
@MockitoSettings(strictness = Strictness.LENIENT)
-public class ConsoleRegistryLockActionTest {
+public class ConsoleRegistryLockActionTest extends ConsoleActionBaseTestCase {

  private static final String EXPECTED_EMAIL_MESSAGE =
      """
@@ -81,16 +77,9 @@ public class ConsoleRegistryLockActionTest {
      https://registrarconsole.tld/console/#/registry-lock-verify?lockVerificationCode=\
      123456789ABCDEFGHJKLMNPQRSTUVWXY""";

-  private final FakeClock fakeClock = new FakeClock(DateTime.parse("2024-04-18T12:00:00.000Z"));
-
-  @RegisterExtension
-  final JpaTestExtensions.JpaIntegrationTestExtension jpa =
-      new JpaTestExtensions.Builder().withClock(fakeClock).buildIntegrationTestExtension();
-
  @Mock GmailClient gmailClient;
  private ConsoleRegistryLockAction action;
  private Domain defaultDomain;
-  private FakeResponse response;
  private User user;

  @BeforeEach
@@ -118,15 +107,15 @@ public class ConsoleRegistryLockActionTest {

  @Test
  void testGet_simpleLock() {
-    saveRegistryLock(createDefaultLockBuilder().setLockCompletionTime(fakeClock.nowUtc()).build());
+    saveRegistryLock(createDefaultLockBuilder().setLockCompletionTime(clock.nowUtc()).build());
    action.run();
    assertThat(response.getStatus()).isEqualTo(SC_OK);
    assertThat(response.getPayload())
        .isEqualTo(
            """
 [{"domainName":"example.test","registrarPocId":"johndoe@theregistrar.com","lockRequestTime":\
-{"creationTime":"2024-04-18T12:00:00.000Z"},"unlockRequestTime":"null","lockCompletionTime":\
-"2024-04-18T12:00:00.000Z","unlockCompletionTime":"null","isSuperuser":false}]\
+{"creationTime":"2024-04-15T00:00:00.000Z"},"unlockRequestTime":"null","lockCompletionTime":\
+"2024-04-15T00:00:00.000Z","unlockCompletionTime":"null","isSuperuser":false}]\
 """);
  }

@@ -148,11 +137,11 @@ public class ConsoleRegistryLockActionTest {
            .setRegistrarId("TheRegistrar")
            .setVerificationCode("123456789ABCDEFGHJKLMNPQRSTUVWXY")
            .setRegistrarPocId("johndoe@theregistrar.com")
-            .setLockCompletionTime(fakeClock.nowUtc())
-            .setUnlockRequestTime(fakeClock.nowUtc())
+            .setLockCompletionTime(clock.nowUtc())
+            .setUnlockRequestTime(clock.nowUtc())
            .build();
    saveRegistryLock(expiredUnlock);
-    fakeClock.advanceBy(Duration.standardDays(1));
+    clock.advanceBy(Duration.standardDays(1));

    RegistryLock regularLock =
        new RegistryLock.Builder()
@@ -161,9 +150,9 @@ public class ConsoleRegistryLockActionTest {
            .setRegistrarId("TheRegistrar")
            .setVerificationCode("123456789ABCDEFGHJKLMNPQRSTUVWXY")
            .setRegistrarPocId("johndoe@theregistrar.com")
-            .setLockCompletionTime(fakeClock.nowUtc())
+            .setLockCompletionTime(clock.nowUtc())
            .build();
-    fakeClock.advanceOneMilli();
+    clock.advanceOneMilli();
    RegistryLock adminLock =
        new RegistryLock.Builder()
            .setRepoId("repoId")
@@ -171,7 +160,7 @@ public class ConsoleRegistryLockActionTest {
            .setRegistrarId("TheRegistrar")
            .setVerificationCode("122222222ABCDEFGHJKLMNPQRSTUVWXY")
            .isSuperuser(true)
-            .setLockCompletionTime(fakeClock.nowUtc())
+            .setLockCompletionTime(clock.nowUtc())
            .build();
    RegistryLock incompleteLock =
        new RegistryLock.Builder()
@@ -189,8 +178,8 @@ public class ConsoleRegistryLockActionTest {
            .setRegistrarId("TheRegistrar")
            .setVerificationCode("123456789ABCDEFGHJKLMNPQRSTUVWXY")
            .setRegistrarPocId("johndoe@theregistrar.com")
-            .setLockCompletionTime(fakeClock.nowUtc())
-            .setUnlockRequestTime(fakeClock.nowUtc())
+            .setLockCompletionTime(clock.nowUtc())
+            .setUnlockRequestTime(clock.nowUtc())
            .build();

    RegistryLock unlockedLock =
@@ -200,9 +189,9 @@ public class ConsoleRegistryLockActionTest {
            .setRegistrarId("TheRegistrar")
            .setRegistrarPocId("johndoe@theregistrar.com")
            .setVerificationCode("123456789ABCDEFGHJKLMNPQRSTUUUUU")
-            .setLockCompletionTime(fakeClock.nowUtc())
-            .setUnlockRequestTime(fakeClock.nowUtc())
-            .setUnlockCompletionTime(fakeClock.nowUtc())
+            .setLockCompletionTime(clock.nowUtc())
+            .setUnlockRequestTime(clock.nowUtc())
+            .setUnlockCompletionTime(clock.nowUtc())
            .build();

    saveRegistryLock(regularLock);
@@ -218,24 +207,24 @@ public class ConsoleRegistryLockActionTest {
    assertThat(response.getPayload())
        .isEqualTo(
            """
-[{"domainName":"adminexample.test","lockRequestTime":{"creationTime":"2024-04-19T12:00:00.001Z"},\
-"unlockRequestTime":"null","lockCompletionTime":"2024-04-19T12:00:00.001Z","unlockCompletionTime":\
+[{"domainName":"adminexample.test","lockRequestTime":{"creationTime":"2024-04-16T00:00:00.001Z"},\
+"unlockRequestTime":"null","lockCompletionTime":"2024-04-16T00:00:00.001Z","unlockCompletionTime":\
 "null","isSuperuser":true},\
 \
 {"domainName":"example.test","registrarPocId":"johndoe@theregistrar.com","lockRequestTime":\
-{"creationTime":"2024-04-19T12:00:00.001Z"},"unlockRequestTime":"null","lockCompletionTime":\
-"2024-04-19T12:00:00.000Z","unlockCompletionTime":"null","isSuperuser":false},\
+{"creationTime":"2024-04-16T00:00:00.001Z"},"unlockRequestTime":"null","lockCompletionTime":\
+"2024-04-16T00:00:00.000Z","unlockCompletionTime":"null","isSuperuser":false},\
 \
 {"domainName":"expiredunlock.test","registrarPocId":"johndoe@theregistrar.com","lockRequestTime":\
-{"creationTime":"2024-04-18T12:00:00.000Z"},"unlockRequestTime":"2024-04-18T12:00:00.000Z",\
-"lockCompletionTime":"2024-04-18T12:00:00.000Z","unlockCompletionTime":"null","isSuperuser":false},\
+{"creationTime":"2024-04-15T00:00:00.000Z"},"unlockRequestTime":"2024-04-15T00:00:00.000Z",\
+"lockCompletionTime":"2024-04-15T00:00:00.000Z","unlockCompletionTime":"null","isSuperuser":false},\
 \
 {"domainName":"incompleteunlock.test","registrarPocId":"johndoe@theregistrar.com","lockRequestTime":\
-{"creationTime":"2024-04-19T12:00:00.001Z"},"unlockRequestTime":"2024-04-19T12:00:00.001Z",\
-"lockCompletionTime":"2024-04-19T12:00:00.001Z","unlockCompletionTime":"null","isSuperuser":false},\
+{"creationTime":"2024-04-16T00:00:00.001Z"},"unlockRequestTime":"2024-04-16T00:00:00.001Z",\
+"lockCompletionTime":"2024-04-16T00:00:00.001Z","unlockCompletionTime":"null","isSuperuser":false},\
 \
 {"domainName":"pending.test","registrarPocId":"johndoe@theregistrar.com","lockRequestTime":\
-{"creationTime":"2024-04-19T12:00:00.001Z"},"unlockRequestTime":"null","lockCompletionTime":"null",\
+{"creationTime":"2024-04-16T00:00:00.001Z"},"unlockRequestTime":"null","lockCompletionTime":"null",\
 "unlockCompletionTime":"null","isSuperuser":false}]""");
  }

@@ -288,7 +277,7 @@ public class ConsoleRegistryLockActionTest {

  @Test
  void testPost_unlock() throws Exception {
-    saveRegistryLock(createDefaultLockBuilder().setLockCompletionTime(fakeClock.nowUtc()).build());
+    saveRegistryLock(createDefaultLockBuilder().setLockCompletionTime(clock.nowUtc()).build());
    persistResource(defaultDomain.asBuilder().setStatusValues(REGISTRY_LOCK_STATUSES).build());
    action = createDefaultPostAction(false);
    action.run();
@@ -301,7 +290,7 @@ public class ConsoleRegistryLockActionTest {

  @Test
  void testPost_unlock_relockDuration() throws Exception {
-    saveRegistryLock(createDefaultLockBuilder().setLockCompletionTime(fakeClock.nowUtc()).build());
+    saveRegistryLock(createDefaultLockBuilder().setLockCompletionTime(clock.nowUtc()).build());
    persistResource(defaultDomain.asBuilder().setStatusValues(REGISTRY_LOCK_STATUSES).build());
    action =
        createPostAction(
@@ -318,10 +307,7 @@ public class ConsoleRegistryLockActionTest {
  @Test
  void testPost_adminUnlockingAdmin() throws Exception {
    saveRegistryLock(
-        createDefaultLockBuilder()
-            .setLockCompletionTime(fakeClock.nowUtc())
-            .isSuperuser(true)
-            .build());
+        createDefaultLockBuilder().setLockCompletionTime(clock.nowUtc()).isSuperuser(true).build());
    persistResource(defaultDomain.asBuilder().setStatusValues(REGISTRY_LOCK_STATUSES).build());
    user =
        user.asBuilder()
@@ -387,10 +373,7 @@ public class ConsoleRegistryLockActionTest {
  @Test
  void testPost_failure_nonAdminUnlockingAdmin() throws Exception {
    saveRegistryLock(
-        createDefaultLockBuilder()
-            .setLockCompletionTime(fakeClock.nowUtc())
-            .isSuperuser(true)
-            .build());
+        createDefaultLockBuilder().setLockCompletionTime(clock.nowUtc()).isSuperuser(true).build());
    persistResource(defaultDomain.asBuilder().setStatusValues(REGISTRY_LOCK_STATUSES).build());
    action = createDefaultPostAction(false);
    action.run();
@@ -464,9 +447,9 @@ public class ConsoleRegistryLockActionTest {
  void testPost_failure_alreadyUnlocked() throws Exception {
    saveRegistryLock(
        createDefaultLockBuilder()
-            .setLockCompletionTime(fakeClock.nowUtc())
-            .setUnlockRequestTime(fakeClock.nowUtc())
-            .setUnlockCompletionTime(fakeClock.nowUtc())
+            .setLockCompletionTime(clock.nowUtc())
+            .setUnlockRequestTime(clock.nowUtc())
+            .setUnlockCompletionTime(clock.nowUtc())
            .build());
    action = createDefaultPostAction(false);
    action.run();
@@ -501,7 +484,7 @@ public class ConsoleRegistryLockActionTest {
        new DomainLockUtils(
            new DeterministicStringGenerator(StringGenerator.Alphabets.BASE_58),
            "adminreg",
-            new CloudTasksHelper(fakeClock).getTestCloudTasksUtils());
+            new CloudTasksHelper(clock).getTestCloudTasksUtils());
    response = (FakeResponse) params.response();
    return new ConsoleRegistryLockAction(
        params, domainLockUtils, gmailClient, optionalPostInput, "TheRegistrar");
--- a/core/src/test/java/google/registry/ui/server/console/ConsoleRegistryLockVerifyActionTest.java
+++ b/core/src/test/java/google/registry/ui/server/console/ConsoleRegistryLockVerifyActionTest.java
@@ -30,12 +30,10 @@ import google.registry.model.console.UserRoles;
 import google.registry.model.domain.Domain;
 import google.registry.model.domain.RegistryLock;
 import google.registry.model.eppcommon.StatusValue;
-import google.registry.persistence.transaction.JpaTestExtensions;
 import google.registry.request.auth.AuthResult;
 import google.registry.testing.CloudTasksHelper;
 import google.registry.testing.ConsoleApiParamsUtils;
 import google.registry.testing.DeterministicStringGenerator;
-import google.registry.testing.FakeClock;
 import google.registry.testing.FakeResponse;
 import google.registry.tools.DomainLockUtils;
 import google.registry.util.StringGenerator;
@@ -43,19 +41,11 @@ import jakarta.servlet.http.HttpServletResponse;
 import org.joda.time.Duration;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.RegisterExtension;

 /** Tests for {@link ConsoleRegistryLockVerifyAction}. */
-public class ConsoleRegistryLockVerifyActionTest {
+public class ConsoleRegistryLockVerifyActionTest extends ConsoleActionBaseTestCase {

  private static final String DEFAULT_CODE = "123456789ABCDEFGHJKLMNPQRSTUUUUU";
-  private final FakeClock fakeClock = new FakeClock();
-
-  @RegisterExtension
-  final JpaTestExtensions.JpaIntegrationTestExtension jpa =
-      new JpaTestExtensions.Builder().withClock(fakeClock).buildIntegrationTestExtension();
-
-  private FakeResponse response;
  private Domain defaultDomain;
  private User user;

@@ -96,8 +86,8 @@ public class ConsoleRegistryLockVerifyActionTest {
    persistResource(defaultDomain.asBuilder().setStatusValues(REGISTRY_LOCK_STATUSES).build());
    saveRegistryLock(
        createDefaultLockBuilder()
-            .setLockCompletionTime(fakeClock.nowUtc())
-            .setUnlockRequestTime(fakeClock.nowUtc())
+            .setLockCompletionTime(clock.nowUtc())
+            .setUnlockRequestTime(clock.nowUtc())
            .build());
    action.run();
    assertThat(response.getStatus()).isEqualTo(HttpServletResponse.SC_OK);
@@ -130,8 +120,8 @@ public class ConsoleRegistryLockVerifyActionTest {
    saveRegistryLock(
        createDefaultLockBuilder()
            .isSuperuser(true)
-            .setLockCompletionTime(fakeClock.nowUtc())
-            .setUnlockRequestTime(fakeClock.nowUtc())
+            .setLockCompletionTime(clock.nowUtc())
+            .setUnlockRequestTime(clock.nowUtc())
            .build());
    user =
        user.asBuilder()
@@ -159,7 +149,7 @@ public class ConsoleRegistryLockVerifyActionTest {
  @Test
  void testFailure_expiredLock() {
    saveRegistryLock(createDefaultLockBuilder().build());
-    fakeClock.advanceBy(Duration.standardDays(1));
+    clock.advanceBy(Duration.standardDays(1));
    action.run();
    assertThat(response.getStatus()).isEqualTo(HttpServletResponse.SC_BAD_REQUEST);
    assertThat(response.getPayload()).isEqualTo("The pending lock has expired; please try again");
@@ -181,8 +171,8 @@ public class ConsoleRegistryLockVerifyActionTest {
    saveRegistryLock(
        createDefaultLockBuilder()
            .isSuperuser(true)
-            .setLockCompletionTime(fakeClock.nowUtc())
-            .setUnlockRequestTime(fakeClock.nowUtc())
+            .setLockCompletionTime(clock.nowUtc())
+            .setUnlockRequestTime(clock.nowUtc())
            .build());
    action.run();
    assertThat(response.getStatus()).isEqualTo(HttpServletResponse.SC_BAD_REQUEST);
@@ -209,7 +199,7 @@ public class ConsoleRegistryLockVerifyActionTest {
        new DomainLockUtils(
            new DeterministicStringGenerator(StringGenerator.Alphabets.BASE_58),
            "adminreg",
-            new CloudTasksHelper(fakeClock).getTestCloudTasksUtils());
+            new CloudTasksHelper(clock).getTestCloudTasksUtils());
    response = (FakeResponse) params.response();
    return new ConsoleRegistryLockVerifyAction(params, domainLockUtils, verificationCode);
  }
--- a/core/src/test/java/google/registry/ui/server/console/ConsoleUpdateRegistrarActionTest.java
+++ b/core/src/test/java/google/registry/ui/server/console/ConsoleUpdateRegistrarActionTest.java
@@ -28,22 +28,17 @@ import static org.mockito.Mockito.when;

 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableSet;
-import com.google.gson.Gson;
 import google.registry.model.console.ConsoleUpdateHistory;
 import google.registry.model.console.GlobalRole;
 import google.registry.model.console.User;
 import google.registry.model.console.UserRoles;
 import google.registry.model.registrar.Registrar;
 import google.registry.model.registrar.RegistrarPoc;
-import google.registry.persistence.transaction.JpaTestExtensions;
 import google.registry.request.Action;
 import google.registry.request.RequestModule;
 import google.registry.request.auth.AuthResult;
 import google.registry.testing.ConsoleApiParamsUtils;
-import google.registry.testing.FakeClock;
-import google.registry.testing.FakeResponse;
 import google.registry.testing.SystemPropertyExtension;
-import google.registry.tools.GsonUtils;
 import google.registry.util.EmailMessage;
 import google.registry.util.RegistryEnvironment;
 import jakarta.mail.internet.AddressException;
@@ -59,11 +54,7 @@ import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.RegisterExtension;

 /** Tests for {@link google.registry.ui.server.console.ConsoleUpdateRegistrarAction}. */
-class ConsoleUpdateRegistrarActionTest {
-  private static final Gson GSON = GsonUtils.provideGson();
-  private final FakeClock clock = new FakeClock(DateTime.parse("2025-01-01T00:00:00.000Z"));
-  private ConsoleApiParams consoleApiParams;
-  private FakeResponse response;
+class ConsoleUpdateRegistrarActionTest extends ConsoleActionBaseTestCase {

  private Registrar registrar;

@@ -77,10 +68,6 @@ class ConsoleUpdateRegistrarActionTest {
  @Order(Integer.MAX_VALUE)
  final SystemPropertyExtension systemPropertyExtension = new SystemPropertyExtension();

-  @RegisterExtension
-  final JpaTestExtensions.JpaIntegrationTestExtension jpa =
-      new JpaTestExtensions.Builder().withClock(clock).buildIntegrationTestExtension();
-
  @BeforeEach
  void beforeEach() throws Exception {
    createTlds("app", "dev");
@@ -98,7 +85,6 @@ class ConsoleUpdateRegistrarActionTest {
                .setEmailAddress("user@registrarId.com")
                .setUserRoles(new UserRoles.Builder().setGlobalRole(GlobalRole.FTE).build())
                .build());
-    consoleApiParams = createParams();
  }

  @Test
@@ -110,12 +96,12 @@ class ConsoleUpdateRegistrarActionTest {
                "TheRegistrar",
                "app, dev",
                false,
-                "\"2024-12-12T00:00:00.000Z\""));
+                "\"2023-12-12T00:00:00.000Z\""));
    action.run();
    Registrar newRegistrar = Registrar.loadByRegistrarId("TheRegistrar").get();
    assertThat(newRegistrar.getAllowedTlds()).containsExactly("app", "dev");
    assertThat(newRegistrar.isRegistryLockAllowed()).isFalse();
-    assertThat(((FakeResponse) consoleApiParams.response()).getStatus()).isEqualTo(SC_OK);
+    assertThat(response.getStatus()).isEqualTo(SC_OK);
    ConsoleUpdateHistory history = loadSingleton(ConsoleUpdateHistory.class).get();
    assertThat(history.getType()).isEqualTo(ConsoleUpdateHistory.Type.REGISTRAR_UPDATE);
    assertThat(history.getDescription()).hasValue("TheRegistrar");
@@ -143,8 +129,8 @@ class ConsoleUpdateRegistrarActionTest {
                false,
                "\"2025-02-01T00:00:00.000Z\""));
    action.run();
-    assertThat(((FakeResponse) consoleApiParams.response()).getStatus()).isEqualTo(SC_BAD_REQUEST);
-    assertThat((String) ((FakeResponse) consoleApiParams.response()).getPayload())
+    assertThat(response.getStatus()).isEqualTo(SC_BAD_REQUEST);
+    assertThat((String) response.getPayload())
        .contains("Invalid value of LastPocVerificationDate - value is in the future");
  }

@@ -160,8 +146,8 @@ class ConsoleUpdateRegistrarActionTest {
                false,
                "\"2024-12-12T00:00:00.000Z\""));
    action.run();
-    assertThat(((FakeResponse) consoleApiParams.response()).getStatus()).isEqualTo(SC_BAD_REQUEST);
-    assertThat((String) ((FakeResponse) consoleApiParams.response()).getPayload())
+    assertThat(response.getStatus()).isEqualTo(SC_BAD_REQUEST);
+    assertThat((String) response.getPayload())
        .contains("Cannot modify allowed TLDs if there is no WHOIS abuse contact set");
  }

@@ -188,12 +174,12 @@ class ConsoleUpdateRegistrarActionTest {
                "TheRegistrar",
                "app, dev",
                false,
-                "\"2024-12-12T00:00:00.000Z\""));
+                "\"2023-12-12T00:00:00.000Z\""));
    action.run();
    Registrar newRegistrar = Registrar.loadByRegistrarId("TheRegistrar").get();
    assertThat(newRegistrar.getAllowedTlds()).containsExactly("app", "dev");
    assertThat(newRegistrar.isRegistryLockAllowed()).isFalse();
-    assertThat(((FakeResponse) consoleApiParams.response()).getStatus()).isEqualTo(SC_OK);
+    assertThat(response.getStatus()).isEqualTo(SC_OK);
  }

  @Test
@@ -205,7 +191,7 @@ class ConsoleUpdateRegistrarActionTest {
                "TheRegistrar",
                "app, dev",
                false,
-                "\"2024-12-12T00:00:00.000Z\""));
+                "\"2023-12-12T00:00:00.000Z\""));
    action.run();
    verify(consoleApiParams.sendEmailUtils().gmailClient, times(1))
        .sendEmail(
@@ -215,11 +201,11 @@ class ConsoleUpdateRegistrarActionTest {
                        + " environment")
                .setBody(
                    "The following changes were made in registry unittest environment to the"
-                        + " registrar TheRegistrar by user user@registrarId.com:\n"
+                        + " registrar TheRegistrar by admin fte@email.tld:\n"
                        + "\n"
                        + "allowedTlds: null -> [app, dev]\n"
                        + "lastPocVerificationDate: 1970-01-01T00:00:00.000Z ->"
-                        + " 2024-12-12T00:00:00.000Z\n")
+                        + " 2023-12-12T00:00:00.000Z\n")
                .setRecipients(ImmutableList.of(new InternetAddress("notification@test.example")))
                .build());
  }
--- a/core/src/test/java/google/registry/ui/server/console/ConsoleUserDataActionTest.java
+++ b/core/src/test/java/google/registry/ui/server/console/ConsoleUserDataActionTest.java
@@ -21,13 +21,8 @@ import static jakarta.servlet.http.HttpServletResponse.SC_UNAUTHORIZED;
 import static org.mockito.Mockito.when;

 import com.google.common.collect.ImmutableMap;
-import com.google.gson.Gson;
-import google.registry.model.console.User;
-import google.registry.persistence.transaction.JpaTestExtensions;
-import google.registry.request.RequestModule;
 import google.registry.request.auth.AuthResult;
 import google.registry.testing.ConsoleApiParamsUtils;
-import google.registry.testing.DatabaseHelper;
 import google.registry.testing.FakeResponse;
 import jakarta.servlet.http.Cookie;
 import java.io.IOException;
@@ -35,41 +30,25 @@ import java.util.List;
 import java.util.Map;
 import java.util.Optional;
 import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.RegisterExtension;

 /** Tests for {@link google.registry.ui.server.console.ConsoleUserDataAction}. */
-class ConsoleUserDataActionTest {
-
-  private static final Gson GSON = RequestModule.provideGson();
-
-  private ConsoleApiParams consoleApiParams;
-
-  @RegisterExtension
-  final JpaTestExtensions.JpaIntegrationTestExtension jpa =
-      new JpaTestExtensions.Builder().buildIntegrationTestExtension();
+class ConsoleUserDataActionTest extends ConsoleActionBaseTestCase {

  @Test
  void testSuccess_hasXSRFCookie() throws IOException {
-    User user = DatabaseHelper.createAdminUser("email@email.com");
-    AuthResult authResult = AuthResult.createUser(user);
-    ConsoleUserDataAction action =
-        createAction(Optional.of(ConsoleApiParamsUtils.createFake(authResult)));
+    ConsoleUserDataAction action = createAction(Optional.of(consoleApiParams));
    action.run();
-    List<Cookie> cookies = ((FakeResponse) consoleApiParams.response()).getCookies();
+    List<Cookie> cookies = response.getCookies();
    assertThat(cookies.stream().map(cookie -> cookie.getName()).collect(toImmutableList()))
        .containsExactly("X-CSRF-Token");
  }

  @Test
  void testSuccess_getContactInfo() throws IOException {
-    User user = DatabaseHelper.createAdminUser("email@email.com");
-    AuthResult authResult = AuthResult.createUser(user);
-    ConsoleUserDataAction action =
-        createAction(Optional.of(ConsoleApiParamsUtils.createFake(authResult)));
+    ConsoleUserDataAction action = createAction(Optional.of(consoleApiParams));
    action.run();
-    assertThat(((FakeResponse) consoleApiParams.response()).getStatus()).isEqualTo(SC_OK);
-    Map jsonObject =
-        GSON.fromJson(((FakeResponse) consoleApiParams.response()).getPayload(), Map.class);
+    assertThat(response.getStatus()).isEqualTo(SC_OK);
+    Map jsonObject = GSON.fromJson(response.getPayload(), Map.class);
    assertThat(jsonObject)
        .containsExactly(
            "userRoles",
@@ -92,7 +71,7 @@ class ConsoleUserDataActionTest {
  void testFailure_notAuthenticated() throws IOException {
    ConsoleUserDataAction action = createAction(Optional.empty());
    action.run();
-    assertThat(((FakeResponse) consoleApiParams.response()).getStatus()).isEqualTo(SC_UNAUTHORIZED);
+    assertThat(response.getStatus()).isEqualTo(SC_UNAUTHORIZED);
  }

  private ConsoleUserDataAction createAction(Optional<ConsoleApiParams> maybeConsoleApiParams)
@@ -101,6 +80,7 @@ class ConsoleUserDataActionTest {
        maybeConsoleApiParams.orElseGet(
            () -> ConsoleApiParamsUtils.createFake(AuthResult.NOT_AUTHENTICATED));
    when(consoleApiParams.request().getMethod()).thenReturn("GET");
+    response = (FakeResponse) consoleApiParams.response();
    return new ConsoleUserDataAction(
        consoleApiParams, "Nomulus", "support@example.com", "+1 (212) 867 5309", "test");
  }
--- a/core/src/test/java/google/registry/ui/server/console/ConsoleUsersActionTest.java
+++ b/core/src/test/java/google/registry/ui/server/console/ConsoleUsersActionTest.java
@@ -29,14 +29,11 @@ import com.google.api.services.directory.Directory.Users.Delete;
 import com.google.api.services.directory.Directory.Users.Insert;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
-import com.google.gson.Gson;
 import google.registry.model.console.GlobalRole;
 import google.registry.model.console.RegistrarRole;
 import google.registry.model.console.User;
 import google.registry.model.console.UserRoles;
 import google.registry.persistence.VKey;
-import google.registry.persistence.transaction.JpaTestExtensions;
-import google.registry.request.RequestModule;
 import google.registry.request.auth.AuthResult;
 import google.registry.testing.CloudTasksHelper;
 import google.registry.testing.ConsoleApiParamsUtils;
@@ -53,11 +50,8 @@ import java.util.stream.Collectors;
 import java.util.stream.IntStream;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.RegisterExtension;

-class ConsoleUsersActionTest {
-
-  private static final Gson GSON = RequestModule.provideGson();
+class ConsoleUsersActionTest extends ConsoleActionBaseTestCase {

  private final Directory directory = mock(Directory.class);
  private final Users users = mock(Users.class);
@@ -70,12 +64,6 @@ class ConsoleUsersActionTest {
  private StringGenerator passwordGenerator =
      new DeterministicStringGenerator("abcdefghijklmnopqrstuvwxyz");

-  private ConsoleApiParams consoleApiParams;
-
-  @RegisterExtension
-  final JpaTestExtensions.JpaIntegrationTestExtension jpa =
-      new JpaTestExtensions.Builder().buildIntegrationTestExtension();
-
  @BeforeEach
  void beforeEach() {
    User dbUser1 =
@@ -130,7 +118,6 @@ class ConsoleUsersActionTest {
            Optional.of("GET"),
            Optional.empty());
    action.run();
-    var response = ((FakeResponse) consoleApiParams.response());
    assertThat(response.getPayload())
        .isEqualTo(
            "[{\"emailAddress\":\"test1@test.com\",\"role\":\"PRIMARY_CONTACT\"},{\"emailAddress\":\"test2@test.com\",\"role\":\"PRIMARY_CONTACT\"}]");
@@ -155,7 +142,6 @@ class ConsoleUsersActionTest {
            Optional.of("GET"),
            Optional.empty());
    action.run();
-    var response = ((FakeResponse) consoleApiParams.response());
    assertThat(response.getStatus()).isEqualTo(HttpServletResponse.SC_FORBIDDEN);
  }

@@ -172,7 +158,6 @@ class ConsoleUsersActionTest {
    when(directory.users()).thenReturn(users);
    when(users.insert(any(com.google.api.services.directory.model.User.class))).thenReturn(insert);
    action.run();
-    var response = ((FakeResponse) consoleApiParams.response());
    assertThat(response.getStatus()).isEqualTo(SC_BAD_REQUEST);
    assertThat(response.getPayload()).contains("Email prefix is invalid");
  }
@@ -190,7 +175,6 @@ class ConsoleUsersActionTest {
    when(directory.users()).thenReturn(users);
    when(users.insert(any(com.google.api.services.directory.model.User.class))).thenReturn(insert);
    action.run();
-    var response = ((FakeResponse) consoleApiParams.response());
    assertThat(response.getStatus()).isEqualTo(SC_CREATED);
    assertThat(response.getPayload())
        .contains(
@@ -215,7 +199,6 @@ class ConsoleUsersActionTest {
    when(directory.users()).thenReturn(users);
    when(users.delete(any(String.class))).thenReturn(delete);
    action.run();
-    var response = ((FakeResponse) consoleApiParams.response());
    assertThat(response.getStatus()).isEqualTo(SC_FORBIDDEN);
    assertThat(response.getPayload())
        .contains("Can't update user not associated with registrarId TheRegistrar");
@@ -234,7 +217,6 @@ class ConsoleUsersActionTest {
    when(directory.users()).thenReturn(users);
    when(users.delete(any(String.class))).thenReturn(delete);
    action.run();
-    var response = ((FakeResponse) consoleApiParams.response());
    assertThat(response.getStatus()).isEqualTo(SC_BAD_REQUEST);
    assertThat(response.getPayload()).contains("User email-1@email.com doesn't exist");
  }
@@ -258,7 +240,6 @@ class ConsoleUsersActionTest {
    when(directory.users()).thenReturn(users);
    when(users.delete(any(String.class))).thenReturn(delete);
    action.run();
-    var response = ((FakeResponse) consoleApiParams.response());
    assertThat(response.getStatus()).isEqualTo(SC_OK);
    assertThat(DatabaseHelper.loadByKeyIfPresent(VKey.create(User.class, "test2@test.com")))
        .isEmpty();
@@ -299,7 +280,6 @@ class ConsoleUsersActionTest {
    when(directory.users()).thenReturn(users);
    when(users.delete(any(String.class))).thenReturn(delete);
    action.run();
-    var response = ((FakeResponse) consoleApiParams.response());
    assertThat(response.getStatus()).isEqualTo(SC_OK);
    Optional<User> actualUser =
        DatabaseHelper.loadByKeyIfPresent(VKey.create(User.class, "test4@test.com"));
@@ -343,7 +323,6 @@ class ConsoleUsersActionTest {
    when(directory.users()).thenReturn(users);
    when(users.insert(any(com.google.api.services.directory.model.User.class))).thenReturn(insert);
    action.run();
-    var response = ((FakeResponse) consoleApiParams.response());
    assertThat(response.getStatus()).isEqualTo(SC_BAD_REQUEST);
    assertThat(response.getPayload()).contains("Total users amount per registrar is limited to 4");
  }
@@ -372,7 +351,6 @@ class ConsoleUsersActionTest {
                new UserData("test2@test.com", RegistrarRole.ACCOUNT_MANAGER.toString(), null)));
    action.cloudTasksUtils = cloudTasksHelper.getTestCloudTasksUtils();
    action.run();
-    var response = ((FakeResponse) consoleApiParams.response());
    assertThat(response.getStatus()).isEqualTo(SC_OK);
    assertThat(
            DatabaseHelper.loadByKey(VKey.create(User.class, "test2@test.com"))
@@ -398,7 +376,6 @@ class ConsoleUsersActionTest {
            Optional.of(
                new UserData("test3@test.com", RegistrarRole.ACCOUNT_MANAGER.toString(), null)));
    action.run();
-    var response = ((FakeResponse) consoleApiParams.response());
    assertThat(response.getStatus()).isEqualTo(SC_FORBIDDEN);
    assertThat(response.getPayload())
        .contains("Can't update user not associated with registrarId TheRegistrar");
@@ -413,6 +390,7 @@ class ConsoleUsersActionTest {
        maybeConsoleApiParams.orElseGet(
            () -> ConsoleApiParamsUtils.createFake(AuthResult.NOT_AUTHENTICATED));
    when(consoleApiParams.request().getMethod()).thenReturn(method.orElse("GET"));
+    response = (FakeResponse) consoleApiParams.response();
    return new ConsoleUsersAction(
        consoleApiParams,
        directory,
--- a/core/src/test/java/google/registry/ui/server/console/RegistrarsActionTest.java
+++ b/core/src/test/java/google/registry/ui/server/console/RegistrarsActionTest.java
@@ -28,7 +28,6 @@ import static org.mockito.Mockito.when;

 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
-import com.google.gson.Gson;
 import google.registry.model.console.ConsoleUpdateHistory;
 import google.registry.model.console.GlobalRole;
 import google.registry.model.console.RegistrarRole;
@@ -36,7 +35,6 @@ import google.registry.model.console.User;
 import google.registry.model.console.UserRoles;
 import google.registry.model.registrar.Registrar;
 import google.registry.model.registrar.RegistrarPoc;
-import google.registry.persistence.transaction.JpaTestExtensions;
 import google.registry.request.Action;
 import google.registry.request.RequestModule;
 import google.registry.request.auth.AuthResult;
@@ -51,13 +49,9 @@ import java.util.Map;
 import java.util.Optional;
 import java.util.stream.Collectors;
 import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.RegisterExtension;

 /** Tests for {@link google.registry.ui.server.console.RegistrarsAction}. */
-class RegistrarsActionTest {
-
-  private static final Gson GSON = RequestModule.provideGson();
-  private ConsoleApiParams consoleApiParams;
+class RegistrarsActionTest extends ConsoleActionBaseTestCase {

  private StringGenerator passwordGenerator =
      new DeterministicStringGenerator("abcdefghijklmnopqrstuvwxyz");
@@ -94,10 +88,6 @@ class RegistrarsActionTest {
          "{ \"street\": [\"test street\"], \"city\": \"test city\", \"state\": \"test state\","
              + " \"zip\": \"00700\", \"countryCode\": \"US\" }");

-  @RegisterExtension
-  final JpaTestExtensions.JpaIntegrationTestExtension jpa =
-      new JpaTestExtensions.Builder().buildIntegrationTestExtension();
-
  @Test
  void testSuccess_onlyRealAndOteRegistrars() {
    Registrar registrar = persistNewRegistrar("registrarId");
@@ -115,8 +105,8 @@ class RegistrarsActionTest {
                createUser(
                    new UserRoles.Builder().setGlobalRole(GlobalRole.SUPPORT_LEAD).build())));
    action.run();
-    assertThat(((FakeResponse) consoleApiParams.response()).getStatus()).isEqualTo(SC_OK);
-    String payload = ((FakeResponse) consoleApiParams.response()).getPayload();
+    assertThat(response.getStatus()).isEqualTo(SC_OK);
+    String payload = response.getPayload();

    var actualRegistrarIds =
        ImmutableList.copyOf(GSON.fromJson(payload, Registrar[].class)).stream()
@@ -135,8 +125,8 @@ class RegistrarsActionTest {
            AuthResult.createUser(
                createUser(new UserRoles.Builder().setGlobalRole(GlobalRole.FTE).build())));
    action.run();
-    assertThat(((FakeResponse) consoleApiParams.response()).getStatus()).isEqualTo(SC_OK);
-    String payload = ((FakeResponse) consoleApiParams.response()).getPayload();
+    assertThat(response.getStatus()).isEqualTo(SC_OK);
+    String payload = response.getPayload();
    assertThat(
            ImmutableList.of(
                    "\"registrarId\":\"NewRegistrar\"",
@@ -162,8 +152,8 @@ class RegistrarsActionTest {
                        .build())));

    action.run();
-    assertThat(((FakeResponse) consoleApiParams.response()).getStatus()).isEqualTo(SC_OK);
-    String payload = ((FakeResponse) consoleApiParams.response()).getPayload();
+    assertThat(response.getStatus()).isEqualTo(SC_OK);
+    String payload = response.getPayload();
    Registrar[] registrars = GSON.fromJson(payload, Registrar[].class);
    assertThat(registrars).hasLength(1);
    assertThat(registrars[0].getRegistrarId()).isEqualTo("registrarId");
@@ -171,12 +161,9 @@ class RegistrarsActionTest {

  @Test
  void testSuccess_createRegistrar() {
-    RegistrarsAction action =
-        createAction(
-            Action.Method.POST,
-            AuthResult.createUser(createUser(new UserRoles.Builder().setIsAdmin(true).build())));
+    RegistrarsAction action = createAction(Action.Method.POST, AuthResult.createUser(fteUser));
    action.run();
-    assertThat(((FakeResponse) consoleApiParams.response()).getStatus()).isEqualTo(SC_OK);
+    assertThat(response.getStatus()).isEqualTo(SC_OK);
    Registrar r = loadRegistrar("regIdTest");
    assertThat(r).isNotNull();
    assertThat(
@@ -202,14 +189,10 @@ class RegistrarsActionTest {
                          .filter(entry -> !entry.getKey().equals(key))
                          .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue)));
              RegistrarsAction action =
-                  createAction(
-                      Action.Method.POST,
-                      AuthResult.createUser(
-                          createUser(new UserRoles.Builder().setIsAdmin(true).build())));
+                  createAction(Action.Method.POST, AuthResult.createUser(fteUser));
              action.run();
-              assertThat(((FakeResponse) consoleApiParams.response()).getStatus())
-                  .isEqualTo(SC_BAD_REQUEST);
-              assertThat(((FakeResponse) consoleApiParams.response()).getPayload())
+              assertThat(response.getStatus()).isEqualTo(SC_BAD_REQUEST);
+              assertThat(response.getPayload())
                  .isEqualTo(
                      String.format(
                          "Missing value for %s", userFriendlyKeysToRegistrarKeys.get(key)));
@@ -219,13 +202,10 @@ class RegistrarsActionTest {
  @Test
  void testFailure_createRegistrar_existingRegistrar() {
    saveRegistrar("regIdTest");
-    RegistrarsAction action =
-        createAction(
-            Action.Method.POST,
-            AuthResult.createUser(createUser(new UserRoles.Builder().setIsAdmin(true).build())));
+    RegistrarsAction action = createAction(Action.Method.POST, AuthResult.createUser(fteUser));
    action.run();
-    assertThat(((FakeResponse) consoleApiParams.response()).getStatus()).isEqualTo(SC_BAD_REQUEST);
-    assertThat(((FakeResponse) consoleApiParams.response()).getPayload())
+    assertThat(response.getStatus()).isEqualTo(SC_BAD_REQUEST);
+    assertThat(response.getPayload())
        .isEqualTo("Registrar with registrarId regIdTest already exists");
  }

@@ -237,6 +217,7 @@ class RegistrarsActionTest {
  private RegistrarsAction createAction(Action.Method method, AuthResult authResult) {
    consoleApiParams = ConsoleApiParamsUtils.createFake(authResult);
    when(consoleApiParams.request().getMethod()).thenReturn(method.toString());
+    response = (FakeResponse) consoleApiParams.response();
    if (method.equals(Action.Method.GET)) {
      return new RegistrarsAction(
          consoleApiParams, Optional.ofNullable(null), passwordGenerator, passcodeGenerator);
--- a/core/src/test/java/google/registry/ui/server/console/domains/ConsoleBulkDomainActionTest.java
+++ b/core/src/test/java/google/registry/ui/server/console/domains/ConsoleBulkDomainActionTest.java
@@ -17,7 +17,6 @@ package google.registry.ui.server.console.domains;
 import static com.google.common.truth.Truth.assertThat;
 import static google.registry.model.common.FeatureFlag.FeatureName.MINIMUM_DATASET_CONTACTS_OPTIONAL;
 import static google.registry.model.common.FeatureFlag.FeatureStatus.INACTIVE;
-import static google.registry.testing.DatabaseHelper.createTld;
 import static google.registry.testing.DatabaseHelper.loadByEntity;
 import static google.registry.testing.DatabaseHelper.loadSingleton;
 import static google.registry.testing.DatabaseHelper.persistActiveContact;
@@ -33,36 +32,28 @@ import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.ImmutableSortedMap;
-import com.google.gson.Gson;
 import com.google.gson.JsonElement;
 import google.registry.flows.DaggerEppTestComponent;
 import google.registry.flows.EppController;
 import google.registry.flows.EppTestComponent;
 import google.registry.model.common.FeatureFlag;
 import google.registry.model.console.ConsoleUpdateHistory;
-import google.registry.model.console.GlobalRole;
 import google.registry.model.console.RegistrarRole;
 import google.registry.model.console.User;
 import google.registry.model.console.UserRoles;
 import google.registry.model.domain.Domain;
 import google.registry.model.eppcommon.StatusValue;
-import google.registry.persistence.transaction.JpaTestExtensions;
 import google.registry.request.auth.AuthResult;
 import google.registry.testing.ConsoleApiParamsUtils;
-import google.registry.testing.FakeClock;
 import google.registry.testing.FakeResponse;
-import google.registry.tools.GsonUtils;
+import google.registry.ui.server.console.ConsoleActionBaseTestCase;
 import google.registry.ui.server.console.ConsoleApiParams;
 import java.util.Optional;
-import org.joda.time.DateTime;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.RegisterExtension;

 /** Tests for {@link ConsoleBulkDomainAction}. */
-public class ConsoleBulkDomainActionTest {
-
-  private static final Gson GSON = GsonUtils.provideGson();
+public class ConsoleBulkDomainActionTest extends ConsoleActionBaseTestCase {

  private static ImmutableSet<StatusValue> serverSuspensionStatuses =
      ImmutableSet.of(
@@ -72,14 +63,7 @@ public class ConsoleBulkDomainActionTest {
          StatusValue.SERVER_DELETE_PROHIBITED,
          StatusValue.SERVER_HOLD);

-  private final FakeClock clock = new FakeClock(DateTime.parse("2024-05-13T00:00:00.000Z"));
-
-  @RegisterExtension
-  final JpaTestExtensions.JpaIntegrationTestExtension jpa =
-      new JpaTestExtensions.Builder().withClock(clock).buildIntegrationTestExtension();
-
  private EppController eppController;
-  private FakeResponse fakeResponse;
  private Domain domain;

  @BeforeEach
@@ -96,7 +80,6 @@ public class ConsoleBulkDomainActionTest {
            .build()
            .startRequest()
            .eppController();
-    createTld("tld");
    domain =
        persistDomainWithDependentResources(
            "example",
@@ -115,8 +98,8 @@ public class ConsoleBulkDomainActionTest {
            GSON.toJsonTree(
                ImmutableMap.of("domainList", ImmutableList.of("example.tld"), "reason", "test")));
    action.run();
-    assertThat(fakeResponse.getStatus()).isEqualTo(SC_OK);
-    assertThat(fakeResponse.getPayload())
+    assertThat(response.getStatus()).isEqualTo(SC_OK);
+    assertThat(response.getPayload())
        .isEqualTo(
            """
 {"example.tld":{"message":"Command completed successfully; action pending",\
@@ -129,22 +112,14 @@ public class ConsoleBulkDomainActionTest {

  @Test
  void testSuccess_suspend() throws Exception {
-    User adminUser =
-        persistResource(
-            new User.Builder()
-                .setEmailAddress("email@email.com")
-                .setUserRoles(
-                    new UserRoles.Builder().setGlobalRole(GlobalRole.FTE).setIsAdmin(true).build())
-                .build());
    ConsoleBulkDomainAction action =
        createAction(
            "SUSPEND",
            GSON.toJsonTree(
-                ImmutableMap.of("domainList", ImmutableList.of("example.tld"), "reason", "test")),
-            adminUser);
+                ImmutableMap.of("domainList", ImmutableList.of("example.tld"), "reason", "test")));
    action.run();
-    assertThat(fakeResponse.getStatus()).isEqualTo(SC_OK);
-    assertThat(fakeResponse.getPayload())
+    assertThat(response.getStatus()).isEqualTo(SC_OK);
+    assertThat(response.getPayload())
        .isEqualTo(
            """
            {"example.tld":{"message":"Command completed successfully","responseCode":1000}}""");
@@ -157,25 +132,17 @@ public class ConsoleBulkDomainActionTest {

  @Test
  void testSuccess_unsuspend() throws Exception {
-    User adminUser =
-        persistResource(
-            new User.Builder()
-                .setEmailAddress("email@email.com")
-                .setUserRoles(
-                    new UserRoles.Builder().setGlobalRole(GlobalRole.FTE).setIsAdmin(true).build())
-                .build());
    persistResource(domain.asBuilder().addStatusValues(serverSuspensionStatuses).build());
    ConsoleBulkDomainAction action =
        createAction(
            "UNSUSPEND",
            GSON.toJsonTree(
-                ImmutableMap.of("domainList", ImmutableList.of("example.tld"), "reason", "test")),
-            adminUser);
+                ImmutableMap.of("domainList", ImmutableList.of("example.tld"), "reason", "test")));
    assertThat(loadByEntity(domain).getStatusValues())
        .containsAtLeastElementsIn(serverSuspensionStatuses);
    action.run();
-    assertThat(fakeResponse.getStatus()).isEqualTo(SC_OK);
-    assertThat(fakeResponse.getPayload())
+    assertThat(response.getStatus()).isEqualTo(SC_OK);
+    assertThat(response.getPayload())
        .isEqualTo(
            """
            {"example.tld":{"message":"Command completed successfully","responseCode":1000}}""");
@@ -197,8 +164,8 @@ public class ConsoleBulkDomainActionTest {
                    "reason",
                    "test")));
    action.run();
-    assertThat(fakeResponse.getStatus()).isEqualTo(SC_OK);
-    assertThat(fakeResponse.getPayload())
+    assertThat(response.getStatus()).isEqualTo(SC_OK);
+    assertThat(response.getPayload())
        .isEqualTo(
            """
 {"example.tld":{"message":"Command completed successfully; action pending","responseCode":1001},\
@@ -214,8 +181,8 @@ public class ConsoleBulkDomainActionTest {
  void testFailure_badActionString() {
    ConsoleBulkDomainAction action = createAction("bad", GSON.toJsonTree(ImmutableMap.of()));
    action.run();
-    assertThat(fakeResponse.getStatus()).isEqualTo(SC_BAD_REQUEST);
-    assertThat(fakeResponse.getPayload())
+    assertThat(response.getStatus()).isEqualTo(SC_BAD_REQUEST);
+    assertThat(response.getPayload())
        .isEqualTo(
            "No enum constant"
                + " google.registry.ui.server.console.domains.ConsoleDomainActionType.BulkAction.bad");
@@ -225,8 +192,8 @@ public class ConsoleBulkDomainActionTest {
  void testFailure_emptyBody() {
    ConsoleBulkDomainAction action = createAction("DELETE", null);
    action.run();
-    assertThat(fakeResponse.getStatus()).isEqualTo(SC_BAD_REQUEST);
-    assertThat(fakeResponse.getPayload()).isEqualTo("Bulk action payload must be present");
+    assertThat(response.getStatus()).isEqualTo(SC_BAD_REQUEST);
+    assertThat(response.getPayload()).isEqualTo("Bulk action payload must be present");
  }

  @Test
@@ -247,7 +214,7 @@ public class ConsoleBulkDomainActionTest {
                        .build())
                .build());
    action.run();
-    assertThat(fakeResponse.getStatus()).isEqualTo(SC_FORBIDDEN);
+    assertThat(response.getStatus()).isEqualTo(SC_FORBIDDEN);
  }

  // @ptkach - reenable with suspend change
@@ -271,21 +238,14 @@ public class ConsoleBulkDomainActionTest {
  // }

  private ConsoleBulkDomainAction createAction(String action, JsonElement payload) {
-    User user =
-        persistResource(
-            new User.Builder()
-                .setEmailAddress("email@email.com")
-                .setUserRoles(
-                    new UserRoles.Builder().setIsAdmin(true).setGlobalRole(GlobalRole.FTE).build())
-                .build());
-    return createAction(action, payload, user);
+    return createAction(action, payload, fteUser);
  }

  private ConsoleBulkDomainAction createAction(String action, JsonElement payload, User user) {
    AuthResult authResult = AuthResult.createUser(user);
    ConsoleApiParams params = ConsoleApiParamsUtils.createFake(authResult);
    when(params.request().getMethod()).thenReturn("POST");
-    fakeResponse = (FakeResponse) params.response();
+    response = (FakeResponse) params.response();
    return new ConsoleBulkDomainAction(
        params, eppController, "TheRegistrar", action, Optional.ofNullable(payload));
  }
--- a/core/src/test/java/google/registry/ui/server/console/settings/ContactActionTest.java
+++ b/core/src/test/java/google/registry/ui/server/console/settings/ContactActionTest.java
@@ -20,7 +20,6 @@ import static google.registry.model.registrar.RegistrarPoc.Type.ABUSE;
 import static google.registry.model.registrar.RegistrarPoc.Type.ADMIN;
 import static google.registry.model.registrar.RegistrarPoc.Type.MARKETING;
 import static google.registry.model.registrar.RegistrarPoc.Type.TECH;
-import static google.registry.testing.DatabaseHelper.createAdminUser;
 import static google.registry.testing.DatabaseHelper.insertInDb;
 import static google.registry.testing.DatabaseHelper.loadAllOf;
 import static google.registry.testing.SqlHelper.saveRegistrar;
@@ -36,19 +35,16 @@ import static org.mockito.Mockito.when;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.ImmutableSet;
-import com.google.gson.Gson;
 import google.registry.model.console.RegistrarRole;
 import google.registry.model.console.User;
 import google.registry.model.console.UserRoles;
 import google.registry.model.registrar.Registrar;
 import google.registry.model.registrar.RegistrarPoc;
-import google.registry.persistence.transaction.JpaTestExtensions;
 import google.registry.request.Action;
-import google.registry.request.RequestModule;
 import google.registry.request.auth.AuthResult;
 import google.registry.testing.ConsoleApiParamsUtils;
 import google.registry.testing.FakeResponse;
-import google.registry.ui.server.console.ConsoleApiParams;
+import google.registry.ui.server.console.ConsoleActionBaseTestCase;
 import google.registry.util.EmailMessage;
 import jakarta.mail.internet.AddressException;
 import jakarta.mail.internet.InternetAddress;
@@ -57,10 +53,9 @@ import java.util.HashMap;
 import java.util.Optional;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.RegisterExtension;

 /** Tests for {@link google.registry.ui.server.console.settings.ContactAction}. */
-class ContactActionTest {
+class ContactActionTest extends ConsoleActionBaseTestCase {
  private static String jsonRegistrar1 =
      "{\"name\":\"Test Registrar 1\","
          + "\"emailAddress\":\"test.registrar1@example.com\","
@@ -70,17 +65,10 @@ class ContactActionTest {
          + "\"visibleInWhoisAsTech\":false,\"visibleInDomainWhoisAsAbuse\":false}";

  private Registrar testRegistrar;
-  private ConsoleApiParams consoleApiParams;
  private RegistrarPoc adminPoc;
  private RegistrarPoc techPoc;
  private RegistrarPoc marketingPoc;

-  private static final Gson GSON = RequestModule.provideGson();
-
-  @RegisterExtension
-  final JpaTestExtensions.JpaIntegrationTestExtension jpa =
-      new JpaTestExtensions.Builder().buildIntegrationTestExtension();
-
  @BeforeEach
  void beforeEach() {
    testRegistrar = saveRegistrar("registrarId");
@@ -122,28 +110,19 @@ class ContactActionTest {
  @Test
  void testSuccess_getContactInfo() throws IOException {
    insertInDb(adminPoc);
-    ContactAction action =
-        createAction(
-            Action.Method.GET,
-            AuthResult.createUser(createAdminUser("email@email.com")),
-            testRegistrar.getRegistrarId());
+    ContactAction action = createAction(Action.Method.GET, fteUser, testRegistrar.getRegistrarId());
    action.run();
-    assertThat(((FakeResponse) consoleApiParams.response()).getStatus()).isEqualTo(SC_OK);
-    assertThat(((FakeResponse) consoleApiParams.response()).getPayload())
-        .isEqualTo("[" + jsonRegistrar1 + "]");
+    assertThat(response.getStatus()).isEqualTo(SC_OK);
+    assertThat(response.getPayload()).isEqualTo("[" + jsonRegistrar1 + "]");
  }

  @Test
  void testSuccess_noOp() throws IOException {
    insertInDb(adminPoc);
    ContactAction action =
-        createAction(
-            Action.Method.POST,
-            AuthResult.createUser(createAdminUser("email@email.com")),
-            testRegistrar.getRegistrarId(),
-            adminPoc);
+        createAction(Action.Method.POST, fteUser, testRegistrar.getRegistrarId(), adminPoc);
    action.run();
-    assertThat(((FakeResponse) consoleApiParams.response()).getStatus()).isEqualTo(SC_OK);
+    assertThat(response.getStatus()).isEqualTo(SC_OK);
    verify(consoleApiParams.sendEmailUtils().gmailClient, never()).sendEmail(any());
  }

@@ -151,14 +130,10 @@ class ContactActionTest {
  void testSuccess_onlyContactsWithNonEmptyType() throws IOException {
    adminPoc = adminPoc.asBuilder().setTypes(ImmutableSet.of()).build();
    insertInDb(adminPoc);
-    ContactAction action =
-        createAction(
-            Action.Method.GET,
-            AuthResult.createUser(createAdminUser("email@email.com")),
-            testRegistrar.getRegistrarId());
+    ContactAction action = createAction(Action.Method.GET, fteUser, testRegistrar.getRegistrarId());
    action.run();
-    assertThat(((FakeResponse) consoleApiParams.response()).getStatus()).isEqualTo(SC_OK);
-    assertThat(((FakeResponse) consoleApiParams.response()).getPayload()).isEqualTo("[]");
+    assertThat(response.getStatus()).isEqualTo(SC_OK);
+    assertThat(response.getPayload()).isEqualTo("[]");
  }

  @Test
@@ -166,13 +141,9 @@ class ContactActionTest {
    insertInDb(adminPoc);
    ContactAction action =
        createAction(
-            Action.Method.POST,
-            AuthResult.createUser(createAdminUser("email@email.com")),
-            testRegistrar.getRegistrarId(),
-            adminPoc,
-            techPoc);
+            Action.Method.POST, fteUser, testRegistrar.getRegistrarId(), adminPoc, techPoc);
    action.run();
-    assertThat(((FakeResponse) consoleApiParams.response()).getStatus()).isEqualTo(SC_OK);
+    assertThat(response.getStatus()).isEqualTo(SC_OK);
    assertThat(
            loadAllOf(RegistrarPoc.class).stream()
                .filter(r -> r.registrarId.equals(testRegistrar.getRegistrarId()))
@@ -186,13 +157,9 @@ class ContactActionTest {
    insertInDb(techPoc.asBuilder().setEmailAddress("incorrect@email.com").build());
    ContactAction action =
        createAction(
-            Action.Method.POST,
-            AuthResult.createUser(createAdminUser("email@email.com")),
-            testRegistrar.getRegistrarId(),
-            adminPoc,
-            techPoc);
+            Action.Method.POST, fteUser, testRegistrar.getRegistrarId(), adminPoc, techPoc);
    action.run();
-    assertThat(((FakeResponse) consoleApiParams.response()).getStatus()).isEqualTo(SC_OK);
+    assertThat(response.getStatus()).isEqualTo(SC_OK);
    HashMap<String, String> testResult = new HashMap<>();
    loadAllOf(RegistrarPoc.class).stream()
        .filter(r -> r.registrarId.equals(testRegistrar.getRegistrarId()))
@@ -210,13 +177,13 @@ class ContactActionTest {
    ContactAction action =
        createAction(
            Action.Method.POST,
-            AuthResult.createUser(createAdminUser("email@email.com")),
+            fteUser,
            testRegistrar.getRegistrarId(),
            adminPoc,
            techPoc.asBuilder().setEmailAddress("test.registrar1@example.com").build());
    action.run();
-    assertThat(((FakeResponse) consoleApiParams.response()).getStatus()).isEqualTo(SC_BAD_REQUEST);
-    assertThat(((FakeResponse) consoleApiParams.response()).getPayload())
+    assertThat(response.getStatus()).isEqualTo(SC_BAD_REQUEST);
+    assertThat(response.getPayload())
        .isEqualTo(
            "One email address (test.registrar1@example.com) cannot be used for multiple contacts");
    assertThat(
@@ -232,13 +199,12 @@ class ContactActionTest {
    ContactAction action =
        createAction(
            Action.Method.POST,
-            AuthResult.createUser(createAdminUser("email@email.com")),
+            fteUser,
            testRegistrar.getRegistrarId(),
            adminPoc.asBuilder().setTypes(ImmutableSet.of(ABUSE)).build());
    action.run();
-    assertThat(((FakeResponse) consoleApiParams.response()).getStatus()).isEqualTo(SC_BAD_REQUEST);
-    assertThat(((FakeResponse) consoleApiParams.response()).getPayload())
-        .isEqualTo("Must have at least one primary contact");
+    assertThat(response.getStatus()).isEqualTo(SC_BAD_REQUEST);
+    assertThat(response.getPayload()).isEqualTo("Must have at least one primary contact");
    assertThat(
            loadAllOf(RegistrarPoc.class).stream()
                .filter(r -> r.registrarId.equals(testRegistrar.getRegistrarId()))
@@ -253,7 +219,7 @@ class ContactActionTest {
    ContactAction action =
        createAction(
            Action.Method.POST,
-            AuthResult.createUser(createAdminUser("email@email.com")),
+            fteUser,
            testRegistrar.getRegistrarId(),
            adminPoc
                .asBuilder()
@@ -261,8 +227,8 @@ class ContactActionTest {
                .setTypes(ImmutableSet.of(ADMIN, TECH))
                .build());
    action.run();
-    assertThat(((FakeResponse) consoleApiParams.response()).getStatus()).isEqualTo(SC_BAD_REQUEST);
-    assertThat(((FakeResponse) consoleApiParams.response()).getPayload())
+    assertThat(response.getStatus()).isEqualTo(SC_BAD_REQUEST);
+    assertThat(response.getPayload())
        .isEqualTo("Please provide a phone number for at least one technical contact");
    assertThat(
            loadAllOf(RegistrarPoc.class).stream()
@@ -276,12 +242,12 @@ class ContactActionTest {
    ContactAction action =
        createAction(
            Action.Method.POST,
-            AuthResult.createUser(createAdminUser("email@email.com")),
+            fteUser,
            testRegistrar.getRegistrarId(),
            adminPoc.asBuilder().setPhoneNumber(null).setVisibleInDomainWhoisAsAbuse(true).build());
    action.run();
-    assertThat(((FakeResponse) consoleApiParams.response()).getStatus()).isEqualTo(SC_BAD_REQUEST);
-    assertThat(((FakeResponse) consoleApiParams.response()).getPayload())
+    assertThat(response.getStatus()).isEqualTo(SC_BAD_REQUEST);
+    assertThat(response.getPayload())
        .isEqualTo("The abuse contact visible in domain WHOIS query must have a phone number");
    assertThat(
            loadAllOf(RegistrarPoc.class).stream()
@@ -297,12 +263,12 @@ class ContactActionTest {
    ContactAction action =
        createAction(
            Action.Method.POST,
-            AuthResult.createUser(createAdminUser("email@email.com")),
+            fteUser,
            testRegistrar.getRegistrarId(),
            adminPoc.asBuilder().setVisibleInDomainWhoisAsAbuse(false).build());
    action.run();
-    assertThat(((FakeResponse) consoleApiParams.response()).getStatus()).isEqualTo(SC_BAD_REQUEST);
-    assertThat(((FakeResponse) consoleApiParams.response()).getPayload())
+    assertThat(response.getStatus()).isEqualTo(SC_BAD_REQUEST);
+    assertThat(response.getPayload())
        .isEqualTo("An abuse contact visible in domain WHOIS query must be designated");
    assertThat(
            loadAllOf(RegistrarPoc.class).stream()
@@ -317,7 +283,7 @@ class ContactActionTest {
    ContactAction action =
        createAction(
            Action.Method.POST,
-            AuthResult.createUser(createAdminUser("email@email.com")),
+            fteUser,
            testRegistrar.getRegistrarId(),
            adminPoc
                .asBuilder()
@@ -325,8 +291,8 @@ class ContactActionTest {
                .setRegistryLockEmailAddress("lock@example.com")
                .build());
    action.run();
-    assertThat(((FakeResponse) consoleApiParams.response()).getStatus()).isEqualTo(SC_BAD_REQUEST);
-    assertThat(((FakeResponse) consoleApiParams.response()).getPayload())
+    assertThat(response.getStatus()).isEqualTo(SC_BAD_REQUEST);
+    assertThat(response.getPayload())
        .isEqualTo("Cannot set registry lock password directly on new contact");
    assertThat(
            loadAllOf(RegistrarPoc.class).stream()
@@ -347,12 +313,12 @@ class ContactActionTest {
    ContactAction action =
        createAction(
            Action.Method.POST,
-            AuthResult.createUser(createAdminUser("email@email.com")),
+            fteUser,
            testRegistrar.getRegistrarId(),
            adminPoc.asBuilder().setRegistryLockEmailAddress("unlock@example.com").build());
    action.run();
-    assertThat(((FakeResponse) consoleApiParams.response()).getStatus()).isEqualTo(SC_BAD_REQUEST);
-    assertThat(((FakeResponse) consoleApiParams.response()).getPayload())
+    assertThat(response.getStatus()).isEqualTo(SC_BAD_REQUEST);
+    assertThat(response.getPayload())
        .isEqualTo("Cannot modify registryLockEmailAddress through the UI");
    assertThat(
            loadAllOf(RegistrarPoc.class).stream()
@@ -374,12 +340,12 @@ class ContactActionTest {
    ContactAction action =
        createAction(
            Action.Method.POST,
-            AuthResult.createUser(createAdminUser("email@email.com")),
+            fteUser,
            testRegistrar.getRegistrarId(),
            adminPoc.asBuilder().setAllowedToSetRegistryLockPassword(true).build());
    action.run();
-    assertThat(((FakeResponse) consoleApiParams.response()).getStatus()).isEqualTo(SC_BAD_REQUEST);
-    assertThat(((FakeResponse) consoleApiParams.response()).getPayload())
+    assertThat(response.getStatus()).isEqualTo(SC_BAD_REQUEST);
+    assertThat(response.getPayload())
        .isEqualTo("Cannot modify isAllowedToSetRegistryLockPassword through the UI");
    assertThat(
            loadAllOf(RegistrarPoc.class).stream()
@@ -392,13 +358,9 @@ class ContactActionTest {
  void testSuccess_sendsEmail() throws IOException, AddressException {
    insertInDb(techPoc.asBuilder().setEmailAddress("incorrect@email.com").build());
    ContactAction action =
-        createAction(
-            Action.Method.POST,
-            AuthResult.createUser(createAdminUser("email@email.com")),
-            testRegistrar.getRegistrarId(),
-            techPoc);
+        createAction(Action.Method.POST, fteUser, testRegistrar.getRegistrarId(), techPoc);
    action.run();
-    assertThat(((FakeResponse) consoleApiParams.response()).getStatus()).isEqualTo(SC_OK);
+    assertThat(response.getStatus()).isEqualTo(SC_OK);
    verify(consoleApiParams.sendEmailUtils().gmailClient, times(1))
        .sendEmail(
            EmailMessage.newBuilder()
@@ -407,7 +369,7 @@ class ContactActionTest {
                        + " environment")
                .setBody(
                    "The following changes were made in registry unittest environment to the"
-                        + " registrar registrarId by admin email@email.com:\n"
+                        + " registrar registrarId by admin fte@email.tld:\n"
                        + "\n"
                        + "contacts:\n"
                        + "    ADDED:\n"
@@ -442,13 +404,9 @@ class ContactActionTest {
    insertInDb(adminPoc, techPoc, marketingPoc);
    ContactAction action =
        createAction(
-            Action.Method.POST,
-            AuthResult.createUser(createAdminUser("email@email.com")),
-            testRegistrar.getRegistrarId(),
-            adminPoc,
-            techPoc);
+            Action.Method.POST, fteUser, testRegistrar.getRegistrarId(), adminPoc, techPoc);
    action.run();
-    assertThat(((FakeResponse) consoleApiParams.response()).getStatus()).isEqualTo(SC_OK);
+    assertThat(response.getStatus()).isEqualTo(SC_OK);
    assertThat(
            loadAllOf(RegistrarPoc.class).stream()
                .filter(r -> r.registrarId.equals(testRegistrar.getRegistrarId()))
@@ -463,43 +421,39 @@ class ContactActionTest {
    ContactAction action =
        createAction(
            Action.Method.POST,
-            AuthResult.createUser(
-                new User.Builder()
-                    .setEmailAddress("email@email.com")
-                    .setUserRoles(
-                        new UserRoles.Builder()
-                            .setRegistrarRoles(
-                                ImmutableMap.of(
-                                    testRegistrar.getRegistrarId(), RegistrarRole.ACCOUNT_MANAGER))
-                            .build())
-                    .build()),
+            new User.Builder()
+                .setEmailAddress("email@email.com")
+                .setUserRoles(
+                    new UserRoles.Builder()
+                        .setRegistrarRoles(
+                            ImmutableMap.of(
+                                testRegistrar.getRegistrarId(), RegistrarRole.ACCOUNT_MANAGER))
+                        .build())
+                .build(),
            testRegistrar.getRegistrarId(),
            techPoc);
    action.run();
-    assertThat(((FakeResponse) consoleApiParams.response()).getStatus()).isEqualTo(SC_FORBIDDEN);
+    assertThat(response.getStatus()).isEqualTo(SC_FORBIDDEN);
  }

  @Test
  void testFailure_changesAdminEmail() throws Exception {
    insertInDb(adminPoc.asBuilder().setEmailAddress("oldemail@example.com").build());
    ContactAction action =
-        createAction(
-            Action.Method.POST,
-            AuthResult.createUser(createAdminUser("email@email.com")),
-            testRegistrar.getRegistrarId(),
-            adminPoc);
+        createAction(Action.Method.POST, fteUser, testRegistrar.getRegistrarId(), adminPoc);
    action.run();
-    FakeResponse fakeResponse = (FakeResponse) consoleApiParams.response();
+    FakeResponse fakeResponse = response;
    assertThat(fakeResponse.getStatus()).isEqualTo(400);
    assertThat(fakeResponse.getPayload())
        .isEqualTo("Cannot remove or change the email address of primary contacts");
  }

  private ContactAction createAction(
-      Action.Method method, AuthResult authResult, String registrarId, RegistrarPoc... contacts)
+      Action.Method method, User user, String registrarId, RegistrarPoc... contacts)
      throws IOException {
-    consoleApiParams = ConsoleApiParamsUtils.createFake(authResult);
+    consoleApiParams = ConsoleApiParamsUtils.createFake(AuthResult.createUser(user));
    when(consoleApiParams.request().getMethod()).thenReturn(method.toString());
+    response = (FakeResponse) consoleApiParams.response();
    if (method.equals(Action.Method.GET)) {
      return new ContactAction(consoleApiParams, registrarId, Optional.empty());
    } else {
--- a/core/src/test/java/google/registry/ui/server/console/settings/RdapRegistrarFieldsActionTest.java
+++ b/core/src/test/java/google/registry/ui/server/console/settings/RdapRegistrarFieldsActionTest.java
@@ -26,13 +26,11 @@ import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.ImmutableSetMultimap;
 import com.google.common.collect.Maps;
-import com.google.gson.Gson;
 import google.registry.model.console.ConsoleUpdateHistory;
 import google.registry.model.console.RegistrarRole;
 import google.registry.model.console.User;
 import google.registry.model.console.UserRoles;
 import google.registry.model.registrar.Registrar;
-import google.registry.persistence.transaction.JpaTestExtensions;
 import google.registry.request.Action;
 import google.registry.request.RequestModule;
 import google.registry.request.auth.AuthResult;
@@ -40,24 +38,18 @@ import google.registry.request.auth.AuthenticatedRegistrarAccessor;
 import google.registry.request.auth.AuthenticatedRegistrarAccessor.Role;
 import google.registry.testing.ConsoleApiParamsUtils;
 import google.registry.testing.DatabaseHelper;
-import google.registry.testing.FakeClock;
 import google.registry.testing.FakeResponse;
-import google.registry.ui.server.console.ConsoleApiParams;
+import google.registry.ui.server.console.ConsoleActionBaseTestCase;
 import google.registry.ui.server.console.ConsoleModule;
 import java.io.BufferedReader;
 import java.io.IOException;
 import java.io.StringReader;
 import java.util.HashMap;
-import org.joda.time.DateTime;
 import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.RegisterExtension;

 /** Tests for {@link RdapRegistrarFieldsAction}. */
-public class RdapRegistrarFieldsActionTest {
+public class RdapRegistrarFieldsActionTest extends ConsoleActionBaseTestCase {

-  private ConsoleApiParams consoleApiParams;
-  private static final Gson GSON = RequestModule.provideGson();
-  private final FakeClock clock = new FakeClock(DateTime.parse("2023-08-01T00:00:00.000Z"));
  private final AuthenticatedRegistrarAccessor registrarAccessor =
      AuthenticatedRegistrarAccessor.createForTesting(
          ImmutableSetMultimap.of("TheRegistrar", Role.OWNER, "NewRegistrar", Role.OWNER));
@@ -81,10 +73,6 @@ public class RdapRegistrarFieldsActionTest {
              "{\"street\": [\"123 Example Boulevard\"], \"city\": \"Williamsburg\", \"state\":"
                  + " \"NY\", \"zip\": \"11201\", \"countryCode\": \"US\"}"));

-  @RegisterExtension
-  final JpaTestExtensions.JpaIntegrationTestExtension jpa =
-      new JpaTestExtensions.Builder().withClock(clock).buildIntegrationTestExtension();
-
  @Test
  void testSuccess_setsAllFields() throws Exception {
    Registrar oldRegistrar = Registrar.loadRequiredRegistrarCached("TheRegistrar");
@@ -113,7 +101,7 @@ public class RdapRegistrarFieldsActionTest {
                + " \"NL\", \"zip\": \"10011\", \"countryCode\": \"CA\"}"));
    RdapRegistrarFieldsAction action = createAction();
    action.run();
-    assertThat(((FakeResponse) consoleApiParams.response()).getStatus()).isEqualTo(SC_OK);
+    assertThat(response.getStatus()).isEqualTo(SC_OK);
    Registrar newRegistrar = Registrar.loadByRegistrarId("TheRegistrar").get(); // skip cache
    assertThat(newRegistrar.getLocalizedAddress().toJsonMap()).isEqualTo(addressMap);
    assertThat(newRegistrar.getPhoneNumber()).isEqualTo("+1.4155552671");
@@ -130,34 +118,30 @@ public class RdapRegistrarFieldsActionTest {
  @Test
  void testFailure_noAccessToRegistrar() throws Exception {
    Registrar newRegistrar = Registrar.loadByRegistrarIdCached("NewRegistrar").get();
-    AuthResult onlyTheRegistrar =
-        AuthResult.createUser(
-            new User.Builder()
-                .setEmailAddress("email@email.example")
-                .setUserRoles(
-                    new UserRoles.Builder()
-                        .setRegistrarRoles(
-                            ImmutableMap.of("TheRegistrar", RegistrarRole.PRIMARY_CONTACT))
-                        .build())
-                .build());
+    User onlyTheRegistrar =
+        new User.Builder()
+            .setEmailAddress("email@email.example")
+            .setUserRoles(
+                new UserRoles.Builder()
+                    .setRegistrarRoles(
+                        ImmutableMap.of("TheRegistrar", RegistrarRole.PRIMARY_CONTACT))
+                    .build())
+            .build();
    uiRegistrarMap.put("registrarId", "NewRegistrar");
    RdapRegistrarFieldsAction action = createAction(onlyTheRegistrar);
    action.run();
-    assertThat(((FakeResponse) consoleApiParams.response()).getStatus()).isEqualTo(SC_FORBIDDEN);
+    assertThat(response.getStatus()).isEqualTo(SC_FORBIDDEN);
    // should be no change
    assertThat(DatabaseHelper.loadByEntity(newRegistrar)).isEqualTo(newRegistrar);
  }

-  private AuthResult defaultUserAuth() {
-    return AuthResult.createUser(DatabaseHelper.createAdminUser("email@email.example"));
-  }
-
  private RdapRegistrarFieldsAction createAction() throws IOException {
-    return createAction(defaultUserAuth());
+    return createAction(fteUser);
  }

-  private RdapRegistrarFieldsAction createAction(AuthResult authResult) throws IOException {
-    consoleApiParams = ConsoleApiParamsUtils.createFake(authResult);
+  private RdapRegistrarFieldsAction createAction(User user) throws IOException {
+    consoleApiParams = ConsoleApiParamsUtils.createFake(AuthResult.createUser(user));
+    response = (FakeResponse) consoleApiParams.response();
    when(consoleApiParams.request().getMethod()).thenReturn(Action.Method.POST.toString());
    doReturn(new BufferedReader(new StringReader(uiRegistrarMap.toString())))
        .when(consoleApiParams.request())
--- a/core/src/test/java/google/registry/ui/server/console/settings/SecurityActionTest.java
+++ b/core/src/test/java/google/registry/ui/server/console/settings/SecurityActionTest.java
@@ -27,20 +27,14 @@ import static org.mockito.Mockito.when;
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.ImmutableSetMultimap;
 import com.google.common.collect.ImmutableSortedMap;
-import com.google.gson.Gson;
 import google.registry.flows.certs.CertificateChecker;
 import google.registry.model.console.ConsoleUpdateHistory;
 import google.registry.model.registrar.Registrar;
-import google.registry.persistence.transaction.JpaTestExtensions;
 import google.registry.request.Action;
 import google.registry.request.RequestModule;
-import google.registry.request.auth.AuthResult;
 import google.registry.request.auth.AuthenticatedRegistrarAccessor;
-import google.registry.testing.ConsoleApiParamsUtils;
-import google.registry.testing.DatabaseHelper;
-import google.registry.testing.FakeClock;
 import google.registry.testing.FakeResponse;
-import google.registry.ui.server.console.ConsoleApiParams;
+import google.registry.ui.server.console.ConsoleActionBaseTestCase;
 import google.registry.ui.server.console.ConsoleModule;
 import java.io.BufferedReader;
 import java.io.IOException;
@@ -49,19 +43,15 @@ import java.util.Optional;
 import org.joda.time.DateTime;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.RegisterExtension;

 /** Tests for {@link google.registry.ui.server.console.settings.SecurityAction}. */
-class SecurityActionTest {
+class SecurityActionTest extends ConsoleActionBaseTestCase {

  private static String jsonRegistrar1 =
      String.format(
          "{\"registrarId\": \"registrarId\", \"clientCertificate\": \"%s\","
              + " \"ipAddressAllowList\": [\"192.168.1.1/32\"]}",
          SAMPLE_CERT2);
-  private static final Gson GSON = RequestModule.provideGson();
-  private ConsoleApiParams consoleApiParams;
-  private final FakeClock clock = new FakeClock();
  private Registrar testRegistrar;

  private AuthenticatedRegistrarAccessor registrarAccessor =
@@ -77,10 +67,6 @@ class SecurityActionTest {
          ImmutableSet.of("secp256r1", "secp384r1"),
          clock);

-  @RegisterExtension
-  final JpaTestExtensions.JpaIntegrationTestExtension jpa =
-      new JpaTestExtensions.Builder().withClock(clock).buildIntegrationTestExtension();
-
  @BeforeEach
  void beforeEach() {
    testRegistrar = saveRegistrar("registrarId");
@@ -91,7 +77,6 @@ class SecurityActionTest {
    clock.setTo(DateTime.parse("2020-11-01T00:00:00Z"));
    SecurityAction action =
        createAction(
-            AuthResult.createUser(DatabaseHelper.createAdminUser("email@email.com")),
            testRegistrar.getRegistrarId());
    action.run();
    assertThat(((FakeResponse) consoleApiParams.response()).getStatus()).isEqualTo(SC_OK);
@@ -105,9 +90,7 @@ class SecurityActionTest {
    assertThat(history.getDescription()).hasValue("registrarId");
  }

-  private SecurityAction createAction(AuthResult authResult, String registrarId)
-      throws IOException {
-    consoleApiParams = ConsoleApiParamsUtils.createFake(authResult);
+  private SecurityAction createAction(String registrarId) throws IOException {
    when(consoleApiParams.request().getMethod()).thenReturn(Action.Method.POST.toString());
    doReturn(new BufferedReader(new StringReader(jsonRegistrar1)))
        .when(consoleApiParams.request())