Populate the host in HostHistory objects in Host flows (#1129)

* Populate the host in HostHistory objects in Host flows
2025-04-30 03:57:51 +02:00 · 2021-05-12 19:11:30 -04:00 · 2021-05-12 19:11:30 -04:00 · 1a664fe95b
commit 1a664fe95b
parent 6e5d42b38d
40 changed files with 68 additions and 58 deletions
--- a/core/src/main/java/google/registry/flows/contact/ContactCreateFlow.java
+++ b/core/src/main/java/google/registry/flows/contact/ContactCreateFlow.java
@ -95,7 +95,7 @@ public final class ContactCreateFlow implements TransactionalFlow {
        .setType(HistoryEntry.Type.CONTACT_CREATE)
        .setModificationTime(now)
        .setXmlBytes(null) // We don't want to store contact details in the history entry.
-        .setContactBase(newContact);
+        .setContact(newContact);
    tm().insertAll(
            ImmutableSet.of(
                newContact,
--- a/core/src/main/java/google/registry/flows/contact/ContactDeleteFlow.java
+++ b/core/src/main/java/google/registry/flows/contact/ContactDeleteFlow.java
@ -125,7 +125,7 @@ public final class ContactDeleteFlow implements TransactionalFlow {
        historyBuilder
            .setType(historyEntryType)
            .setModificationTime(now)
-            .setContactBase(newContact)
+            .setContact(newContact)
            .build();
    if (!tm().isOfy()) {
      handlePendingTransferOnDelete(existingContact, newContact, now, contactHistory);
--- a/core/src/main/java/google/registry/flows/contact/ContactTransferApproveFlow.java
+++ b/core/src/main/java/google/registry/flows/contact/ContactTransferApproveFlow.java
@ -91,7 +91,7 @@ public final class ContactTransferApproveFlow implements TransactionalFlow {
        historyBuilder
            .setType(HistoryEntry.Type.CONTACT_TRANSFER_APPROVE)
            .setModificationTime(now)
-            .setContactBase(newContact)
+            .setContact(newContact)
            .build();
    // Create a poll message for the gaining client.
    PollMessage gainingPollMessage =
--- a/core/src/main/java/google/registry/flows/contact/ContactTransferCancelFlow.java
+++ b/core/src/main/java/google/registry/flows/contact/ContactTransferCancelFlow.java
@ -87,7 +87,7 @@ public final class ContactTransferCancelFlow implements TransactionalFlow {
        historyBuilder
            .setType(HistoryEntry.Type.CONTACT_TRANSFER_CANCEL)
            .setModificationTime(now)
-            .setContactBase(newContact)
+            .setContact(newContact)
            .build();
    // Create a poll message for the losing client.
    PollMessage losingPollMessage =
--- a/core/src/main/java/google/registry/flows/contact/ContactTransferRejectFlow.java
+++ b/core/src/main/java/google/registry/flows/contact/ContactTransferRejectFlow.java
@ -85,7 +85,7 @@ public final class ContactTransferRejectFlow implements TransactionalFlow {
        historyBuilder
            .setType(HistoryEntry.Type.CONTACT_TRANSFER_REJECT)
            .setModificationTime(now)
-            .setContactBase(newContact)
+            .setContact(newContact)
            .build();
    PollMessage gainingPollMessage =
        createGainingTransferPollMessage(
--- a/core/src/main/java/google/registry/flows/contact/ContactTransferRequestFlow.java
+++ b/core/src/main/java/google/registry/flows/contact/ContactTransferRequestFlow.java
@ -153,7 +153,7 @@ public final class ContactTransferRequestFlow implements TransactionalFlow {
    tm().update(newContact);
    tm().insertAll(
            ImmutableSet.of(
-                historyBuilder.setContactBase(newContact).build(),
+                historyBuilder.setContact(newContact).build(),
                requestPollMessage,
                serverApproveGainingPollMessage,
                serverApproveLosingPollMessage));
--- a/core/src/main/java/google/registry/flows/contact/ContactUpdateFlow.java
+++ b/core/src/main/java/google/registry/flows/contact/ContactUpdateFlow.java
@ -149,7 +149,7 @@ public final class ContactUpdateFlow implements TransactionalFlow {
        .setType(HistoryEntry.Type.CONTACT_UPDATE)
        .setModificationTime(now)
        .setXmlBytes(null) // We don't want to store contact details in the history entry.
-        .setContactBase(newContact);
+        .setContact(newContact);
    tm().insert(historyBuilder.build());
    tm().update(newContact);
    return responseBuilder.build();
--- a/core/src/main/java/google/registry/flows/domain/DomainCreateFlow.java
+++ b/core/src/main/java/google/registry/flows/domain/DomainCreateFlow.java
@ -502,7 +502,7 @@ public class DomainCreateFlow implements TransactionalFlow {
        .setType(HistoryEntry.Type.DOMAIN_CREATE)
        .setPeriod(period)
        .setModificationTime(now)
-        .setDomainContent(domain)
+        .setDomain(domain)
        .build();
  }

--- a/core/src/main/java/google/registry/flows/domain/DomainDeleteFlow.java
+++ b/core/src/main/java/google/registry/flows/domain/DomainDeleteFlow.java
@ -331,7 +331,7 @@ public final class DomainDeleteFlow implements TransactionalFlow {
    return historyBuilder
        .setType(HistoryEntry.Type.DOMAIN_DELETE)
        .setModificationTime(now)
-        .setDomainContent(domain)
+        .setDomain(domain)
        .build();
  }

--- a/core/src/main/java/google/registry/flows/domain/DomainRenewFlow.java
+++ b/core/src/main/java/google/registry/flows/domain/DomainRenewFlow.java
@ -233,7 +233,7 @@ public final class DomainRenewFlow implements TransactionalFlow {
        .setType(HistoryEntry.Type.DOMAIN_RENEW)
        .setPeriod(period)
        .setModificationTime(now)
-        .setDomainContent(newDomain)
+        .setDomain(newDomain)
        .setDomainTransactionRecords(
            ImmutableSet.of(
                DomainTransactionRecord.create(
--- a/core/src/main/java/google/registry/flows/domain/DomainRestoreRequestFlow.java
+++ b/core/src/main/java/google/registry/flows/domain/DomainRestoreRequestFlow.java
@ -190,7 +190,7 @@ public final class DomainRestoreRequestFlow implements TransactionalFlow  {
    return historyBuilder
        .setType(HistoryEntry.Type.DOMAIN_RESTORE)
        .setModificationTime(now)
-        .setDomainContent(newDomain)
+        .setDomain(newDomain)
        .setDomainTransactionRecords(
            ImmutableSet.of(
                DomainTransactionRecord.create(
--- a/core/src/main/java/google/registry/flows/domain/DomainTransferApproveFlow.java
+++ b/core/src/main/java/google/registry/flows/domain/DomainTransferApproveFlow.java
@ -243,7 +243,7 @@ public final class DomainTransferApproveFlow implements TransactionalFlow {
        .setType(HistoryEntry.Type.DOMAIN_TRANSFER_APPROVE)
        .setModificationTime(now)
        .setOtherClientId(gainingClientId)
-        .setDomainContent(newDomain)
+        .setDomain(newDomain)
        .setDomainTransactionRecords(
            union(
                cancelingRecords,
--- a/core/src/main/java/google/registry/flows/domain/DomainTransferCancelFlow.java
+++ b/core/src/main/java/google/registry/flows/domain/DomainTransferCancelFlow.java
@ -132,7 +132,7 @@ public final class DomainTransferCancelFlow implements TransactionalFlow {
    return historyBuilder
        .setType(HistoryEntry.Type.DOMAIN_TRANSFER_CANCEL)
        .setModificationTime(now)
-        .setDomainContent(newDomain)
+        .setDomain(newDomain)
        .setDomainTransactionRecords(cancelingRecords)
        .build();
  }
--- a/core/src/main/java/google/registry/flows/domain/DomainTransferRejectFlow.java
+++ b/core/src/main/java/google/registry/flows/domain/DomainTransferRejectFlow.java
@ -137,7 +137,7 @@ public final class DomainTransferRejectFlow implements TransactionalFlow {
            union(
                cancelingRecords,
                DomainTransactionRecord.create(newDomain.getTld(), now, TRANSFER_NACKED, 1)))
-        .setDomainContent(newDomain)
+        .setDomain(newDomain)
        .build();
  }
 }
--- a/core/src/main/java/google/registry/flows/domain/DomainTransferRequestFlow.java
+++ b/core/src/main/java/google/registry/flows/domain/DomainTransferRequestFlow.java
@ -318,7 +318,7 @@ public final class DomainTransferRequestFlow implements TransactionalFlow {
        .setType(HistoryEntry.Type.DOMAIN_TRANSFER_REQUEST)
        .setPeriod(period)
        .setModificationTime(now)
-        .setDomainContent(newDomain)
+        .setDomain(newDomain)
        .setDomainTransactionRecords(
            ImmutableSet.of(
                DomainTransactionRecord.create(
--- a/core/src/main/java/google/registry/flows/domain/DomainUpdateFlow.java
+++ b/core/src/main/java/google/registry/flows/domain/DomainUpdateFlow.java
@ -221,7 +221,7 @@ public final class DomainUpdateFlow implements TransactionalFlow {
    return historyBuilder
        .setType(HistoryEntry.Type.DOMAIN_UPDATE)
        .setModificationTime(now)
-        .setDomainContent(newDomain)
+        .setDomain(newDomain)
        .build();
  }

--- a/core/src/main/java/google/registry/flows/host/HostCreateFlow.java
+++ b/core/src/main/java/google/registry/flows/host/HostCreateFlow.java
@ -45,6 +45,7 @@ import google.registry.model.eppinput.ResourceCommand;
 import google.registry.model.eppoutput.CreateData.HostCreateData;
 import google.registry.model.eppoutput.EppResponse;
 import google.registry.model.host.HostCommand.Create;
+import google.registry.model.host.HostHistory;
 import google.registry.model.host.HostResource;
 import google.registry.model.index.EppResourceIndex;
 import google.registry.model.index.ForeignKeyIndex;
@ -85,7 +86,7 @@ public final class HostCreateFlow implements TransactionalFlow {
  @Inject ExtensionManager extensionManager;
  @Inject @ClientId String clientId;
  @Inject @TargetId String targetId;
-  @Inject HistoryEntry.Builder historyBuilder;
+  @Inject HostHistory.Builder historyBuilder;
  @Inject DnsQueue dnsQueue;
  @Inject EppResponse.Builder responseBuilder;

@ -128,14 +129,11 @@ public final class HostCreateFlow implements TransactionalFlow {
            .setRepoId(createRepoId(ObjectifyService.allocateId(), roidSuffix))
            .setSuperordinateDomain(superordinateDomain.map(DomainBase::createVKey).orElse(null))
            .build();
-    historyBuilder
-        .setType(HistoryEntry.Type.HOST_CREATE)
-        .setModificationTime(now)
-        .setParent(Key.create(newHost));
+    historyBuilder.setType(HistoryEntry.Type.HOST_CREATE).setModificationTime(now).setHost(newHost);
    ImmutableSet<ImmutableObject> entitiesToSave =
        ImmutableSet.of(
            newHost,
-            historyBuilder.build().toChildHistoryEntity(),
+            historyBuilder.build(),
            ForeignKeyIndex.create(newHost, newHost.getDeletionTime()),
            EppResourceIndex.create(Key.create(newHost)));
    if (superordinateDomain.isPresent()) {
--- a/core/src/main/java/google/registry/flows/host/HostDeleteFlow.java
+++ b/core/src/main/java/google/registry/flows/host/HostDeleteFlow.java
@ -130,7 +130,7 @@ public final class HostDeleteFlow implements TransactionalFlow {
      historyEntryType = Type.HOST_DELETE;
      resultCode = SUCCESS;
    }
-    historyBuilder.setType(historyEntryType).setModificationTime(now).setHostBase(newHost);
+    historyBuilder.setType(historyEntryType).setModificationTime(now).setHost(newHost);
    tm().insert(historyBuilder.build());
    tm().update(newHost);
    return responseBuilder.setResultFromCode(resultCode).build();
--- a/core/src/main/java/google/registry/flows/host/HostUpdateFlow.java
+++ b/core/src/main/java/google/registry/flows/host/HostUpdateFlow.java
@ -31,7 +31,6 @@ import static google.registry.persistence.transaction.TransactionManagerFactory.
 import static google.registry.util.CollectionUtils.isNullOrEmpty;

 import com.google.common.collect.ImmutableSet;
-import com.googlecode.objectify.Key;
 import google.registry.batch.AsyncTaskEnqueuer;
 import google.registry.dns.DnsQueue;
 import google.registry.flows.EppException;
@ -55,6 +54,7 @@ import google.registry.model.eppoutput.EppResponse;
 import google.registry.model.host.HostCommand.Update;
 import google.registry.model.host.HostCommand.Update.AddRemove;
 import google.registry.model.host.HostCommand.Update.Change;
+import google.registry.model.host.HostHistory;
 import google.registry.model.host.HostResource;
 import google.registry.model.index.ForeignKeyIndex;
 import google.registry.model.reporting.HistoryEntry;
@ -116,7 +116,7 @@ public final class HostUpdateFlow implements TransactionalFlow {
  @Inject @ClientId String clientId;
  @Inject @TargetId String targetId;
  @Inject @Superuser boolean isSuperuser;
-  @Inject HistoryEntry.Builder historyBuilder;
+  @Inject HostHistory.Builder historyBuilder;
  @Inject AsyncTaskEnqueuer asyncTaskEnqueuer;
  @Inject DnsQueue dnsQueue;
  @Inject EppResponse.Builder responseBuilder;
@ -205,9 +205,8 @@ public final class HostUpdateFlow implements TransactionalFlow {
        historyBuilder
            .setType(HistoryEntry.Type.HOST_UPDATE)
            .setModificationTime(now)
-            .setParent(Key.create(existingHost))
-            .build()
-            .toChildHistoryEntity());
+            .setHost(newHost)
+            .build());
    tm().updateAll(entitiesToUpdate.build());
    tm().insertAll(entitiesToInsert.build());
    return responseBuilder.build();
--- a/core/src/main/java/google/registry/model/contact/ContactHistory.java
+++ b/core/src/main/java/google/registry/model/contact/ContactHistory.java
@ -197,7 +197,7 @@ public class ContactHistory extends HistoryEntry implements SqlEntity {
      super(instance);
    }

-    public Builder setContactBase(@Nullable ContactBase contactBase) {
+    public Builder setContact(@Nullable ContactBase contactBase) {
      // Nullable for the sake of pre-Registry-3.0 history objects
      if (contactBase == null) {
        return this;
--- a/core/src/main/java/google/registry/model/domain/DomainHistory.java
+++ b/core/src/main/java/google/registry/model/domain/DomainHistory.java
@ -345,7 +345,7 @@ public class DomainHistory extends HistoryEntry implements SqlEntity {
      super(instance);
    }

-    public Builder setDomainContent(@Nullable DomainContent domainContent) {
+    public Builder setDomain(@Nullable DomainContent domainContent) {
      // Nullable for the sake of pre-Registry-3.0 history objects
      if (domainContent == null) {
        return this;
--- a/core/src/main/java/google/registry/model/host/HostHistory.java
+++ b/core/src/main/java/google/registry/model/host/HostHistory.java
@ -110,6 +110,9 @@ public class HostHistory extends HistoryEntry implements SqlEntity {
    if (hostBase != null && hostBase.getHostName() == null) {
      hostBase = null;
    }
+    if (hostBase != null && hostBase.getRepoId() == null) {
+      hostBase = hostBase.asBuilder().setRepoId(parent.getName()).build();
+    }
  }

  // In Datastore, save as a HistoryEntry object regardless of this object's type
@ -195,7 +198,7 @@ public class HostHistory extends HistoryEntry implements SqlEntity {
      super(instance);
    }

-    public Builder setHostBase(@Nullable HostBase hostBase) {
+    public Builder setHost(@Nullable HostBase hostBase) {
      // Nullable for the sake of pre-Registry-3.0 history objects
      if (hostBase == null) {
        return this;
--- a/core/src/test/java/google/registry/flows/ResourceFlowTestCase.java
+++ b/core/src/test/java/google/registry/flows/ResourceFlowTestCase.java
@ -196,7 +196,7 @@ public abstract class ResourceFlowTestCase<F extends Flow, R extends EppResource
        // Don't use direct equals comparison since one might be a subclass of the other
        assertAboutImmutableObjects()
            .that(contactHistory.getContactBase().get())
-            .isEqualExceptFields(resource);
+            .hasFieldsEqualTo(resource);
      } else if (resource instanceof DomainContent) {
        DomainHistory domainHistory = (DomainHistory) historyEntry;
        assertAboutImmutableObjects()
@ -204,7 +204,10 @@ public abstract class ResourceFlowTestCase<F extends Flow, R extends EppResource
            .isEqualExceptFields(resource, "gracePeriods", "dsData", "nsHosts");
      } else if (resource instanceof HostBase) {
        HostHistory hostHistory = (HostHistory) historyEntry;
-        assertThat(hostHistory.getHostBase().get()).isEqualTo(resource);
+        // Don't use direct equals comparison since one might be a subclass of the other
+        assertAboutImmutableObjects()
+            .that(hostHistory.getHostBase().get())
+            .hasFieldsEqualTo(resource);
      }
    }
  }
--- a/core/src/test/java/google/registry/flows/domain/DomainTransferCancelFlowTest.java
+++ b/core/src/test/java/google/registry/flows/domain/DomainTransferCancelFlowTest.java
@ -404,7 +404,7 @@ class DomainTransferCancelFlowTest
    persistResource(
        new DomainHistory.Builder()
            .setType(DOMAIN_TRANSFER_REQUEST)
-            .setDomainContent(domain)
+            .setDomain(domain)
            .setModificationTime(clock.nowUtc().minusDays(4))
            .setDomainTransactionRecords(
                ImmutableSet.of(previousSuccessRecord, notCancellableRecord))
--- a/core/src/test/java/google/registry/flows/host/HostCreateFlowTest.java
+++ b/core/src/test/java/google/registry/flows/host/HostCreateFlowTest.java
@ -92,17 +92,19 @@ class HostCreateFlowTest extends ResourceFlowTestCase<HostCreateFlow, HostResour
    clock.advanceOneMilli();
    assertTransactionalFlow(true);
    runFlowAssertResponse(loadFile("host_create_response.xml"));
+    HostResource host = reloadResourceByForeignKey();
    // Check that the host was created and persisted with a history entry.
    assertAboutHosts()
-        .that(reloadResourceByForeignKey())
+        .that(host)
        .hasLastSuperordinateChange(null)
        .and()
        .hasOnlyOneHistoryEntryWhich()
        .hasType(HistoryEntry.Type.HOST_CREATE);
    assertNoBillingEvents();
    if (tm().isOfy()) {
-      assertEppResourceIndexEntityFor(reloadResourceByForeignKey());
+      assertEppResourceIndexEntityFor(host);
    }
+    assertLastHistoryContainsResource(host);
  }

  private void doSuccessfulInternalTest(String tld) throws Exception {
--- a/core/src/test/java/google/registry/flows/host/HostDeleteFlowTest.java
+++ b/core/src/test/java/google/registry/flows/host/HostDeleteFlowTest.java
@ -375,6 +375,7 @@ class HostDeleteFlowTest extends ResourceFlowTestCase<HostDeleteFlow, HostResour
    } else {
      assertNoDnsTasksEnqueued();
    }
+    assertLastHistoryContainsResource(deletedHost);
    assertNoTasksEnqueued(QUEUE_ASYNC_DELETE);
  }

--- a/core/src/test/java/google/registry/flows/host/HostUpdateFlowTest.java
+++ b/core/src/test/java/google/registry/flows/host/HostUpdateFlowTest.java
@ -176,6 +176,7 @@ class HostUpdateFlowTest extends ResourceFlowTestCase<HostUpdateFlow, HostResour
        .hasOnlyOneHistoryEntryWhich()
        .hasType(HistoryEntry.Type.HOST_UPDATE);
    assertNoBillingEvents();
+    assertLastHistoryContainsResource(renamedHost);
    return renamedHost;
  }

--- a/core/src/test/java/google/registry/mapreduce/inputs/ChildEntityInputTest.java
+++ b/core/src/test/java/google/registry/mapreduce/inputs/ChildEntityInputTest.java
@ -80,10 +80,10 @@ class ChildEntityInputTest {
    domainA = persistEppResourceInFirstBucket(newDomainBase("a.tld", contact));
    domainHistoryEntryA =
        persistResource(
-            new DomainHistory.Builder().setDomainContent(domainA).setModificationTime(now).build());
+            new DomainHistory.Builder().setDomain(domainA).setModificationTime(now).build());
    contactHistoryEntry =
        persistResource(
-            new ContactHistory.Builder().setContactBase(contact).setModificationTime(now).build());
+            new ContactHistory.Builder().setContact(contact).setModificationTime(now).build());
    oneTimeA =
        persistResource(
            new BillingEvent.OneTime.Builder()
@ -113,7 +113,7 @@ class ChildEntityInputTest {
    domainB = persistEppResourceInFirstBucket(newDomainBase("b.tld"));
    domainHistoryEntryB =
        persistResource(
-            new DomainHistory.Builder().setDomainContent(domainB).setModificationTime(now).build());
+            new DomainHistory.Builder().setDomain(domainB).setModificationTime(now).build());
    oneTimeB =
        persistResource(
            new BillingEvent.OneTime.Builder()
@ -294,7 +294,7 @@ class ChildEntityInputTest {
      historyEntries.add(
          persistResource(
                  new DomainHistory.Builder()
-                      .setDomainContent(domain)
+                      .setDomain(domain)
                      .setModificationTime(now)
                      .setClientId(i + ".tld")
                      .build())
--- a/core/src/test/java/google/registry/model/ImmutableObjectSubject.java
+++ b/core/src/test/java/google/registry/model/ImmutableObjectSubject.java
@ -51,6 +51,10 @@ public final class ImmutableObjectSubject extends Subject {
    this.actual = actual;
  }

+  public void hasFieldsEqualTo(@Nullable ImmutableObject expected) {
+    isEqualExceptFields(expected);
+  }
+
  public void isEqualExceptFields(
      @Nullable ImmutableObject expected, Iterable<String> ignoredFields) {
    isEqualExceptFields(expected, Iterables.toArray(ignoredFields, String.class));
--- a/core/src/test/java/google/registry/model/billing/BillingEventTest.java
+++ b/core/src/test/java/google/registry/model/billing/BillingEventTest.java
@ -77,7 +77,7 @@ public class BillingEventTest extends EntityTestCase {
    domainHistory =
        persistResource(
            new DomainHistory.Builder()
-                .setDomainContent(domain)
+                .setDomain(domain)
                .setModificationTime(now)
                .setRequestedByRegistrar(false)
                .setType(HistoryEntry.Type.DOMAIN_CREATE)
@ -86,7 +86,7 @@ public class BillingEventTest extends EntityTestCase {
    domainHistory2 =
        persistResource(
            new DomainHistory.Builder()
-                .setDomainContent(domain)
+                .setDomain(domain)
                .setModificationTime(now.plusDays(1))
                .setRequestedByRegistrar(false)
                .setType(HistoryEntry.Type.DOMAIN_CREATE)
--- a/core/src/test/java/google/registry/model/domain/DomainBaseSqlTest.java
+++ b/core/src/test/java/google/registry/model/domain/DomainBaseSqlTest.java
@ -522,7 +522,7 @@ public class DomainBaseSqlTest {
                      .setTransferData(transferData)
                      .setGracePeriods(gracePeriods)
                      .build();
-              historyEntry = historyEntry.asBuilder().setDomainContent(domain).build();
+              historyEntry = historyEntry.asBuilder().setDomain(domain).build();
              jpaTm().insert(historyEntry);
              jpaTm().insert(autorenewPollMessage);
              jpaTm().insert(billEvent);
@ -661,7 +661,7 @@ public class DomainBaseSqlTest {
                      .setTransferData(transferData)
                      .setGracePeriods(gracePeriods)
                      .build();
-              historyEntry = historyEntry.asBuilder().setDomainContent(domain).build();
+              historyEntry = historyEntry.asBuilder().setDomain(domain).build();
              jpaTm().insert(historyEntry);
              jpaTm().insert(autorenewPollMessage);
              jpaTm().insert(billEvent);
--- a/core/src/test/java/google/registry/model/history/ContactHistoryTest.java
+++ b/core/src/test/java/google/registry/model/history/ContactHistoryTest.java
@ -69,7 +69,7 @@ public class ContactHistoryTest extends EntityTestCase {
    ContactHistory contactHistory =
        createContactHistory(contactFromDb, contact.getRepoId())
            .asBuilder()
-            .setContactBase(null)
+            .setContact(null)
            .build();
    jpaTm().transact(() -> jpaTm().insert(contactHistory));

@ -116,7 +116,7 @@ public class ContactHistoryTest extends EntityTestCase {
        .setBySuperuser(false)
        .setReason("reason")
        .setRequestedByRegistrar(true)
-        .setContactBase(contact)
+        .setContact(contact)
        .setContactRepoId(contactRepoId)
        .build();
  }
--- a/core/src/test/java/google/registry/model/history/DomainHistoryTest.java
+++ b/core/src/test/java/google/registry/model/history/DomainHistoryTest.java
@ -86,8 +86,7 @@ public class DomainHistoryTest extends EntityTestCase {
  @TestSqlOnly
  void testLegacyPersistence_nullResource() {
    DomainBase domain = addGracePeriodForSql(createDomainWithContactsAndHosts());
-    DomainHistory domainHistory =
-        createDomainHistory(domain).asBuilder().setDomainContent(null).build();
+    DomainHistory domainHistory = createDomainHistory(domain).asBuilder().setDomain(null).build();
    jpaTm().transact(() -> jpaTm().insert(domainHistory));

    jpaTm()
@ -255,7 +254,7 @@ public class DomainHistoryTest extends EntityTestCase {
        .setBySuperuser(false)
        .setReason("reason")
        .setRequestedByRegistrar(true)
-        .setDomainContent(domain)
+        .setDomain(domain)
        .setDomainRepoId(domain.getRepoId())
        .setDomainTransactionRecords(ImmutableSet.of(transactionRecord))
        .setOtherClientId("otherClient")
--- a/core/src/test/java/google/registry/model/history/HostHistoryTest.java
+++ b/core/src/test/java/google/registry/model/history/HostHistoryTest.java
@ -67,7 +67,7 @@ public class HostHistoryTest extends EntityTestCase {

    HostResource hostFromDb = jpaTm().transact(() -> jpaTm().loadByKey(host.createVKey()));
    HostHistory hostHistory =
-        createHostHistory(hostFromDb, host.getRepoId()).asBuilder().setHostBase(null).build();
+        createHostHistory(hostFromDb, host.getRepoId()).asBuilder().setHost(null).build();
    jpaTm().transact(() -> jpaTm().insert(hostHistory));

    jpaTm()
@ -121,7 +121,7 @@ public class HostHistoryTest extends EntityTestCase {
        .setBySuperuser(false)
        .setReason("reason")
        .setRequestedByRegistrar(true)
-        .setHostBase(hostBase)
+        .setHost(hostBase)
        .setHostRepoId(hostRepoId)
        .build();
  }
--- a/core/src/test/java/google/registry/model/poll/PollMessageExternalKeyConverterTest.java
+++ b/core/src/test/java/google/registry/model/poll/PollMessageExternalKeyConverterTest.java
@ -62,7 +62,7 @@ public class PollMessageExternalKeyConverterTest {
    historyEntry =
        persistResource(
            new DomainHistory.Builder()
-                .setDomainContent(persistActiveDomain("foo.foobar"))
+                .setDomain(persistActiveDomain("foo.foobar"))
                .setType(HistoryEntry.Type.DOMAIN_CREATE)
                .setPeriod(Period.create(1, Period.Unit.YEARS))
                .setXmlBytes("<xml></xml>".getBytes(UTF_8))
--- a/core/src/test/java/google/registry/model/reporting/HistoryEntryDaoTest.java
+++ b/core/src/test/java/google/registry/model/reporting/HistoryEntryDaoTest.java
@ -58,7 +58,7 @@ class HistoryEntryDaoTest extends EntityTestCase {
    // Set up a new persisted DomainHistory entity.
    domainHistory =
        new DomainHistory.Builder()
-            .setDomainContent(domain)
+            .setDomain(domain)
            .setType(HistoryEntry.Type.DOMAIN_CREATE)
            .setPeriod(Period.create(1, Period.Unit.YEARS))
            .setXmlBytes("<xml></xml>".getBytes(UTF_8))
--- a/core/src/test/java/google/registry/model/reporting/HistoryEntryTest.java
+++ b/core/src/test/java/google/registry/model/reporting/HistoryEntryTest.java
@ -55,7 +55,7 @@ class HistoryEntryTest extends EntityTestCase {
    // Set up a new persisted HistoryEntry entity.
    domainHistory =
        new DomainHistory.Builder()
-            .setDomainContent(domain)
+            .setDomain(domain)
            .setType(HistoryEntry.Type.DOMAIN_CREATE)
            .setPeriod(Period.create(1, Period.Unit.YEARS))
            .setXmlBytes("<xml></xml>".getBytes(UTF_8))
--- a/core/src/test/java/google/registry/rde/DomainBaseToXjcConverterTest.java
+++ b/core/src/test/java/google/registry/rde/DomainBaseToXjcConverterTest.java
@ -224,7 +224,7 @@ public class DomainBaseToXjcConverterTest {
            new DomainHistory.Builder()
                .setModificationTime(clock.nowUtc())
                .setType(HistoryEntry.Type.DOMAIN_CREATE)
-                .setDomainContent(domain)
+                .setDomain(domain)
                .build());
    BillingEvent.OneTime billingEvent =
        persistResource(
--- a/core/src/test/java/google/registry/testing/DatabaseHelper.java
+++ b/core/src/test/java/google/registry/testing/DatabaseHelper.java
@ -636,7 +636,7 @@ public class DatabaseHelper {
            new DomainHistory.Builder()
                .setType(HistoryEntry.Type.DOMAIN_CREATE)
                .setModificationTime(now)
-                .setDomainContent(domain)
+                .setDomain(domain)
                .build());
    BillingEvent.Recurring autorenewEvent =
        persistResource(
@ -677,7 +677,7 @@ public class DatabaseHelper {
            new DomainHistory.Builder()
                .setType(HistoryEntry.Type.DOMAIN_TRANSFER_REQUEST)
                .setModificationTime(tm().transact(() -> tm().getTransactionTime()))
-                .setDomainContent(domain)
+                .setDomain(domain)
                .build());
    BillingEvent.OneTime transferBillingEvent =
        persistResource(
--- a/core/src/test/java/google/registry/tools/UpdateDomainCommandTest.java
+++ b/core/src/test/java/google/registry/tools/UpdateDomainCommandTest.java
@ -298,7 +298,7 @@ class UpdateDomainCommandTest extends EppToolCommandTestCase<UpdateDomainCommand
            new DomainHistory.Builder()
                .setModificationTime(fakeClock.nowUtc())
                .setType(DOMAIN_CREATE)
-                .setDomainContent(domain)
+                .setDomain(domain)
                .build());
    BillingEvent.Recurring autorenewBillingEvent =
        persistResource(