zydronium/google-nomulus
1
0
Fork 0
mirror of https://github.com/google/nomulus.git synced 2025-07-20 09:46:03 +02:00
Code Issues Projects Releases Packages Wiki Activity

Remove nearly all uses of ReferenceUnion

Browse source 
ReferenceUnion is a hack to work around the mismatch between how
we store references (by roid) and how they are represented in EPP
(by foreign key). If it ever needed to exist (not entirely clear...)
it should have remained tightly scoped within the domain commands
and resources. Instead it has leaked everywhere in the project,
causing lots of boilerplate. This CL hides all of that behind
standard Refs, and should be followed by work to remove ReferenceUnion
completely.
-------------
Created by MOE: https://github.com/google/moe
MOE_MIGRATED_REVID=122424416
This commit is contained in:
cgoldfeder 2016-05-16 08:55:54 -07:00 • committed by Justine Tunney
parent 56c8bb0f2a
commit 9a2afc7a9b
59 changed files with 448 additions and 454 deletions
Download patch file Download diff file Expand all files Collapse all files

15
javatests/google/registry/dns/writer/dnsupdate/DnsUpdateWriterTest.java
View file

@ -32,8 +32,9 @@ import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
import com.google.common.net.InetAddresses;
import com.googlecode.objectify.Ref;
import google.registry.model.domain.DomainResource;
import google.registry.model.domain.ReferenceUnion;
import google.registry.model.domain.secdns.DelegationSignerData;
import google.registry.model.eppcommon.StatusValue;
import google.registry.model.host.HostResource;
@ -109,8 +110,7 @@ public class DnsUpdateWriterTest {
DomainResource domain =
persistActiveDomain("example.tld")
.asBuilder()
.setNameservers(
ImmutableSet.of(ReferenceUnion.create(host1), ReferenceUnion.create(host2)))
.setNameservers(ImmutableSet.of(Ref.create(host1), Ref.create(host2)))
.build();
persistResource(domain);
@ -129,8 +129,7 @@ public class DnsUpdateWriterTest {
DomainResource domain =
persistActiveDomain("example.tld")
.asBuilder()
.setNameservers(
ImmutableSet.of(ReferenceUnion.create(persistActiveHost("ns1.example.tld"))))
.setNameservers(ImmutableSet.of(Ref.create(persistActiveHost("ns1.example.tld"))))
.setDsData(
ImmutableSet.of(
DelegationSignerData.create(1, 3, 1, base16().decode("0123456789ABCDEF"))))
@ -154,8 +153,7 @@ public class DnsUpdateWriterTest {
persistActiveDomain("example.tld")
.asBuilder()
.addStatusValue(StatusValue.SERVER_HOLD)
.setNameservers(
ImmutableSet.of(ReferenceUnion.create(persistActiveHost("ns1.example.tld"))))
.setNameservers(ImmutableSet.of(Ref.create(persistActiveHost("ns1.example.tld"))))
.build();
persistResource(domain);
@ -223,8 +221,7 @@ public class DnsUpdateWriterTest {
DomainResource domain =
persistActiveDomain("example.tld")
.asBuilder()
.setNameservers(
ImmutableSet.of(ReferenceUnion.create(persistActiveHost("ns1.example.tld"))))
.setNameservers(ImmutableSet.of(Ref.create(persistActiveHost("ns1.example.tld"))))
.build();
persistResource(domain);
when(mockResolver.send(any(Message.class))).thenReturn(messageWithResponseCode(Rcode.SERVFAIL));

4
javatests/google/registry/flows/async/DeleteContactResourceActionTest.java
View file

@ -40,7 +40,6 @@ import google.registry.model.contact.ContactPhoneNumber;
import google.registry.model.contact.ContactResource;
import google.registry.model.contact.PostalInfo;
import google.registry.model.domain.DomainResource;
import google.registry.model.domain.ReferenceUnion;
import google.registry.model.eppcommon.StatusValue;
import google.registry.model.eppcommon.Trid;
import google.registry.model.poll.PendingActionNotificationResponse;
@ -79,8 +78,7 @@ public class DeleteContactResourceActionTest
assertAboutContacts().that(contactUsed).doesNotHaveStatusValue(StatusValue.PENDING_DELETE)
.and().hasDeletionTime(END_OF_TIME);
domain = loadByUniqueId(DomainResource.class, "example.tld", now);
assertThat(domain.getReferencedContacts())
.contains(ReferenceUnion.<ContactResource>create(Ref.create(contactUsed)));
assertThat(domain.getReferencedContacts()).contains(Ref.create(contactUsed));
HistoryEntry historyEntry =
getOnlyHistoryEntryOfType(contactUsed, HistoryEntry.Type.CONTACT_DELETE_FAILURE);
assertPollMessageFor(

4
javatests/google/registry/flows/async/DeleteEppResourceActionTestCase.java
View file

@ -29,11 +29,11 @@ import com.google.common.base.Optional;
import com.google.common.collect.ImmutableSet;
import com.googlecode.objectify.Key;
import com.googlecode.objectify.Ref;
import google.registry.mapreduce.MapreduceRunner;
import google.registry.model.contact.ContactResource;
import google.registry.model.domain.DomainResource;
import google.registry.model.domain.ReferenceUnion;
import google.registry.model.host.HostResource;
import google.registry.model.ofy.Ofy;
import google.registry.model.poll.PollMessage;
@ -84,7 +84,7 @@ public abstract class DeleteEppResourceActionTestCase<T extends DeleteEppResourc
hostUsed = persistActiveHost("ns1.example.tld");
domain = persistResource(
newDomainResource("example.tld", contactUsed).asBuilder()
.setNameservers(ImmutableSet.of(ReferenceUnion.create(hostUsed)))
.setNameservers(ImmutableSet.of(Ref.create(hostUsed)))
.build());
}

4
javatests/google/registry/flows/async/DeleteHostResourceActionTest.java
View file

@ -33,7 +33,6 @@ import com.googlecode.objectify.Key;
import com.googlecode.objectify.Ref;
import google.registry.model.domain.DomainResource;
import google.registry.model.domain.ReferenceUnion;
import google.registry.model.eppcommon.StatusValue;
import google.registry.model.host.HostResource;
import google.registry.model.reporting.HistoryEntry;
@ -68,8 +67,7 @@ public class DeleteHostResourceActionTest
assertAboutHosts().that(hostUsed).doesNotHaveStatusValue(StatusValue.PENDING_DELETE)
.and().hasDeletionTime(END_OF_TIME);
domain = loadByUniqueId(DomainResource.class, "example.tld", now);
assertThat(domain.getNameservers())
.contains(ReferenceUnion.<HostResource>create(Ref.create(hostUsed)));
assertThat(domain.getNameservers()).contains(Ref.create(hostUsed));
HistoryEntry historyEntry =
getOnlyHistoryEntryOfType(hostUsed, HistoryEntry.Type.HOST_DELETE_FAILURE);
assertPollMessageFor(

22
javatests/google/registry/flows/async/DnsRefreshForHostRenameActionTest.java
View file

@ -30,10 +30,10 @@ import com.google.common.base.Optional;
import com.google.common.collect.ImmutableSet;
import com.googlecode.objectify.Key;
import com.googlecode.objectify.Ref;
import google.registry.dns.DnsQueue;
import google.registry.mapreduce.MapreduceRunner;
import google.registry.model.domain.ReferenceUnion;
import google.registry.model.host.HostResource;
import google.registry.request.HttpException.BadRequestException;
import google.registry.testing.ExceptionRule;
@ -77,21 +77,21 @@ public class DnsRefreshForHostRenameActionTest
@Test
public void testSuccess_dnsUpdateEnqueued() throws Exception {
createTld("tld");
HostResource renamedHost = persistActiveHost("ns1.example.tld");
HostResource otherHost = persistActiveHost("ns2.example.tld");
Ref<HostResource> renamedHostRef = Ref.create(persistActiveHost("ns1.example.tld"));
Ref<HostResource> otherHostRef = Ref.create(persistActiveHost("ns2.example.tld"));
persistResource(newDomainApplication("notadomain.tld").asBuilder()
.setNameservers(ImmutableSet.of(ReferenceUnion.create(renamedHost)))
.setNameservers(ImmutableSet.of(renamedHostRef))
.build());
persistResource(newDomainResource("example.tld").asBuilder()
.setNameservers(ImmutableSet.of(ReferenceUnion.create(renamedHost)))
.setNameservers(ImmutableSet.of(renamedHostRef))
.build());
persistResource(newDomainResource("otherexample.tld").asBuilder()
.setNameservers(ImmutableSet.of(ReferenceUnion.create(renamedHost)))
.setNameservers(ImmutableSet.of(renamedHostRef))
.build());
persistResource(newDomainResource("untouched.tld").asBuilder()
.setNameservers(ImmutableSet.of(ReferenceUnion.create(otherHost)))
.setNameservers(ImmutableSet.of(otherHostRef))
.build());
runMapreduce(Key.create(renamedHost).getString());
runMapreduce(renamedHostRef.getKey().getString());
verify(dnsQueue).addDomainRefreshTask("example.tld");
verify(dnsQueue).addDomainRefreshTask("otherexample.tld");
verifyNoMoreInteractions(dnsQueue);
@ -100,12 +100,12 @@ public class DnsRefreshForHostRenameActionTest
@Test
public void testSuccess_noDnsTasksForDeletedDomain() throws Exception {
createTld("tld");
HostResource renamedHost = persistActiveHost("ns1.example.tld");
Ref<HostResource> renamedHostRef = Ref.create(persistActiveHost("ns1.example.tld"));
persistResource(newDomainResource("example.tld").asBuilder()
.setNameservers(ImmutableSet.of(ReferenceUnion.create(renamedHost)))
.setNameservers(ImmutableSet.of(renamedHostRef))
.setDeletionTime(START_OF_TIME)
.build());
runMapreduce(Key.create(renamedHost).getString());
runMapreduce(renamedHostRef.getKey().getString());
verifyZeroInteractions(dnsQueue);
}

4
javatests/google/registry/flows/domain/DomainApplicationCreateFlowTest.java
View file

@ -79,7 +79,7 @@ import google.registry.flows.domain.DomainFlowUtils.LaunchPhaseMismatchException
import google.registry.flows.domain.DomainFlowUtils.LeadingDashException;
import google.registry.flows.domain.DomainFlowUtils.LinkedResourceDoesNotExistException;
import google.registry.flows.domain.DomainFlowUtils.MissingContactTypeException;
import google.registry.flows.domain.DomainFlowUtils.NameserverNotAllowedException;
import google.registry.flows.domain.DomainFlowUtils.NameserversNotAllowedException;
import google.registry.flows.domain.DomainFlowUtils.NoMarksFoundMatchingDomainException;
import google.registry.flows.domain.DomainFlowUtils.NotAuthorizedForTldException;
import google.registry.flows.domain.DomainFlowUtils.PremiumNameBlockedException;
@ -1191,7 +1191,7 @@ public class DomainApplicationCreateFlowTest
persistResource(Registry.get("tld").asBuilder()
.setAllowedFullyQualifiedHostNames(ImmutableSet.of("ns2.example.net"))
.build());
thrown.expect(NameserverNotAllowedException.class, "ns1.example.net");
thrown.expect(NameserversNotAllowedException.class, "ns1.example.net");
runFlow();
}

7
javatests/google/registry/flows/domain/DomainApplicationDeleteFlowTest.java
View file

@ -27,6 +27,8 @@ import static google.registry.testing.GenericEppResourceSubject.assertAboutEppRe
import com.google.common.collect.ImmutableSet;
import com.googlecode.objectify.Ref;
import google.registry.flows.EppException.UnimplementedExtensionException;
import google.registry.flows.FlowRunner.CommitMode;
import google.registry.flows.FlowRunner.UserPrivileges;
@ -41,7 +43,6 @@ import google.registry.flows.domain.DomainFlowUtils.NotAuthorizedForTldException
import google.registry.model.EppResource;
import google.registry.model.contact.ContactResource;
import google.registry.model.domain.DomainApplication;
import google.registry.model.domain.ReferenceUnion;
import google.registry.model.domain.launch.LaunchPhase;
import google.registry.model.eppcommon.StatusValue;
import google.registry.model.host.HostResource;
@ -89,10 +90,10 @@ public class DomainApplicationDeleteFlowTest
persistResource(newDomainApplication("example.tld").asBuilder()
.setRepoId("1-TLD")
.setRegistrant(
ReferenceUnion.create(
Ref.create(
loadByUniqueId(ContactResource.class, "sh8013", clock.nowUtc())))
.setNameservers(ImmutableSet.of(
ReferenceUnion.create(
Ref.create(
loadByUniqueId(HostResource.class, "ns1.example.net", clock.nowUtc()))))
.build());
doSuccessfulTest();

13
javatests/google/registry/flows/domain/DomainApplicationInfoFlowTest.java
View file

@ -26,6 +26,8 @@ import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
import com.googlecode.objectify.Ref;
import google.registry.flows.ResourceFlowTestCase;
import google.registry.flows.ResourceFlowUtils.ResourceNotOwnedException;
import google.registry.flows.ResourceQueryFlow.ResourceToQueryDoesNotExistException;
@ -37,7 +39,6 @@ import google.registry.model.domain.DesignatedContact;
import google.registry.model.domain.DesignatedContact.Type;
import google.registry.model.domain.DomainApplication;
import google.registry.model.domain.DomainAuthInfo;
import google.registry.model.domain.ReferenceUnion;
import google.registry.model.domain.launch.ApplicationStatus;
import google.registry.model.domain.launch.LaunchCreateExtension;
import google.registry.model.domain.launch.LaunchPhase;
@ -89,12 +90,12 @@ public class DomainApplicationInfoFlowTest
.setCreationTimeForTest(DateTime.parse("1999-04-03T22:00:00.0Z"))
.setLastEppUpdateTime(DateTime.parse("1999-12-03T09:00:00.0Z"))
.setLastTransferTime(DateTime.parse("2000-04-08T09:00:00.0Z"))
.setRegistrant(ReferenceUnion.create(registrant))
.setRegistrant(Ref.create(registrant))
.setContacts(ImmutableSet.of(
DesignatedContact.create(Type.ADMIN, ReferenceUnion.create(contact)),
DesignatedContact.create(Type.TECH, ReferenceUnion.create(contact))))
DesignatedContact.create(Type.ADMIN, Ref.create(contact)),
DesignatedContact.create(Type.TECH, Ref.create(contact))))
.setNameservers(hostsState.equals(HostsState.HOSTS_EXIST) ? ImmutableSet.of(
ReferenceUnion.create(host1), ReferenceUnion.create(host2)) : null)
Ref.create(host1), Ref.create(host2)) : null)
.setAuthInfo(DomainAuthInfo.create(PasswordAuth.create("2fooBAR")))
.addStatusValue(StatusValue.PENDING_CREATE)
.setApplicationStatus(ApplicationStatus.PENDING_VALIDATION)
@ -244,7 +245,7 @@ public class DomainApplicationInfoFlowTest
.setDsData(ImmutableSet.of(DelegationSignerData.create(
12345, 3, 1, base16().decode("49FD46E6C4B45C55D4AC"))))
.setNameservers(ImmutableSet.of(
ReferenceUnion.create(host1), ReferenceUnion.create(host2)))
Ref.create(host1), Ref.create(host2)))
.build());
doSuccessfulTest("domain_info_sunrise_response_dsdata.xml", HostsState.NO_HOSTS_EXIST);
}

43
javatests/google/registry/flows/domain/DomainApplicationUpdateFlowTest.java
View file

@ -30,6 +30,8 @@ import static google.registry.util.DateTimeUtils.START_OF_TIME;
import com.google.common.collect.ImmutableSet;
import com.googlecode.objectify.Ref;
import google.registry.flows.EppException.UnimplementedExtensionException;
import google.registry.flows.FlowRunner.CommitMode;
import google.registry.flows.FlowRunner.UserPrivileges;
@ -50,7 +52,7 @@ import google.registry.flows.domain.DomainFlowUtils.LinkedResourceDoesNotExistEx
import google.registry.flows.domain.DomainFlowUtils.MissingAdminContactException;
import google.registry.flows.domain.DomainFlowUtils.MissingContactTypeException;
import google.registry.flows.domain.DomainFlowUtils.MissingTechnicalContactException;
import google.registry.flows.domain.DomainFlowUtils.NameserverNotAllowedException;
import google.registry.flows.domain.DomainFlowUtils.NameserversNotAllowedException;
import google.registry.flows.domain.DomainFlowUtils.NotAuthorizedForTldException;
import google.registry.flows.domain.DomainFlowUtils.RegistrantNotAllowedException;
import google.registry.flows.domain.DomainFlowUtils.TooManyDsRecordsException;
@ -60,7 +62,6 @@ import google.registry.model.domain.DesignatedContact;
import google.registry.model.domain.DesignatedContact.Type;
import google.registry.model.domain.DomainApplication;
import google.registry.model.domain.DomainApplication.Builder;
import google.registry.model.domain.ReferenceUnion;
import google.registry.model.domain.launch.ApplicationStatus;
import google.registry.model.domain.secdns.DelegationSignerData;
import google.registry.model.eppcommon.StatusValue;
@ -108,9 +109,9 @@ public class DomainApplicationUpdateFlowTest
private DomainApplication persistApplication() throws Exception {
return persistResource(newApplicationBuilder()
.setContacts(ImmutableSet.of(
DesignatedContact.create(Type.TECH, ReferenceUnion.create(sh8013Contact)),
DesignatedContact.create(Type.ADMIN, ReferenceUnion.create(unusedContact))))
.setNameservers(ImmutableSet.of(ReferenceUnion.create(
DesignatedContact.create(Type.TECH, Ref.create(sh8013Contact)),
DesignatedContact.create(Type.ADMIN, Ref.create(unusedContact))))
.setNameservers(ImmutableSet.of(Ref.create(
loadByUniqueId(HostResource.class, "ns1.example.tld", clock.nowUtc()))))
.build());
}
@ -174,7 +175,7 @@ public class DomainApplicationUpdateFlowTest
persistReferencedEntities();
ContactResource sh8013 = loadByUniqueId(ContactResource.class, "sh8013", clock.nowUtc());
persistResource(
newApplicationBuilder().setRegistrant(ReferenceUnion.create(sh8013)).build());
newApplicationBuilder().setRegistrant(Ref.create(sh8013)).build());
clock.advanceOneMilli();
runFlowAssertResponse(readFile("domain_update_response.xml"));
}
@ -184,13 +185,13 @@ public class DomainApplicationUpdateFlowTest
setEppInput("domain_update_sunrise_remove_multiple_contacts.xml");
persistReferencedEntities();
ContactResource sh8013 = loadByUniqueId(ContactResource.class, "sh8013", clock.nowUtc());
ReferenceUnion<ContactResource> sh8013ReferenceUnion = ReferenceUnion.create(sh8013);
Ref<ContactResource> sh8013Ref = Ref.create(sh8013);
persistResource(newApplicationBuilder()
.setRegistrant(sh8013ReferenceUnion)
.setRegistrant(sh8013Ref)
.setContacts(ImmutableSet.of(
DesignatedContact.create(Type.ADMIN, sh8013ReferenceUnion),
DesignatedContact.create(Type.BILLING, sh8013ReferenceUnion),
DesignatedContact.create(Type.TECH, sh8013ReferenceUnion)))
DesignatedContact.create(Type.ADMIN, sh8013Ref),
DesignatedContact.create(Type.BILLING, sh8013Ref),
DesignatedContact.create(Type.TECH, sh8013Ref)))
.build());
clock.advanceOneMilli();
runFlowAssertResponse(readFile("domain_update_response.xml"));
@ -373,10 +374,10 @@ public class DomainApplicationUpdateFlowTest
}
private void modifyApplicationToHave13Nameservers() throws Exception {
ImmutableSet.Builder<ReferenceUnion<HostResource>> nameservers = new ImmutableSet.Builder<>();
ImmutableSet.Builder<Ref<HostResource>> nameservers = new ImmutableSet.Builder<>();
for (int i = 1; i < 15; i++) {
if (i != 2) { // Skip 2 since that's the one that the tests will add.
nameservers.add(ReferenceUnion.create(loadByUniqueId(
nameservers.add(Ref.create(loadByUniqueId(
HostResource.class, String.format("ns%d.example.tld", i), clock.nowUtc())));
}
}
@ -496,7 +497,7 @@ public class DomainApplicationUpdateFlowTest
// Add a tech contact to the persisted entity, which should cause the flow to fail when it tries
// to add "mak21" as a second tech contact.
persistResource(reloadResourceByUniqueId().asBuilder().setContacts(ImmutableSet.of(
DesignatedContact.create(Type.TECH, ReferenceUnion.create(
DesignatedContact.create(Type.TECH, Ref.create(
loadByUniqueId(ContactResource.class, "foo", clock.nowUtc()))))).build());
runFlow();
}
@ -581,7 +582,7 @@ public class DomainApplicationUpdateFlowTest
setEppInput("domain_update_sunrise_add_remove_same_host.xml");
persistReferencedEntities();
persistResource(newApplicationBuilder()
.setNameservers(ImmutableSet.of(ReferenceUnion.create(
.setNameservers(ImmutableSet.of(Ref.create(
loadByUniqueId(HostResource.class, "ns1.example.tld", clock.nowUtc()))))
.build());
runFlow();
@ -595,7 +596,7 @@ public class DomainApplicationUpdateFlowTest
persistResource(newApplicationBuilder()
.setContacts(ImmutableSet.of(DesignatedContact.create(
Type.TECH,
ReferenceUnion.create(
Ref.create(
loadByUniqueId(ContactResource.class, "sh8013", clock.nowUtc())))))
.build());
runFlow();
@ -608,8 +609,8 @@ public class DomainApplicationUpdateFlowTest
persistReferencedEntities();
persistResource(newApplicationBuilder()
.setContacts(ImmutableSet.of(
DesignatedContact.create(Type.ADMIN, ReferenceUnion.create(sh8013Contact)),
DesignatedContact.create(Type.TECH, ReferenceUnion.create(sh8013Contact))))
DesignatedContact.create(Type.ADMIN, Ref.create(sh8013Contact)),
DesignatedContact.create(Type.TECH, Ref.create(sh8013Contact))))
.build());
runFlow();
}
@ -621,8 +622,8 @@ public class DomainApplicationUpdateFlowTest
persistReferencedEntities();
persistResource(newApplicationBuilder()
.setContacts(ImmutableSet.of(
DesignatedContact.create(Type.ADMIN, ReferenceUnion.create(sh8013Contact)),
DesignatedContact.create(Type.TECH, ReferenceUnion.create(sh8013Contact))))
DesignatedContact.create(Type.ADMIN, Ref.create(sh8013Contact)),
DesignatedContact.create(Type.TECH, Ref.create(sh8013Contact))))
.build());
runFlow();
}
@ -649,7 +650,7 @@ public class DomainApplicationUpdateFlowTest
.setAllowedFullyQualifiedHostNames(ImmutableSet.of("ns1.example.foo"))
.build());
clock.advanceOneMilli();
thrown.expect(NameserverNotAllowedException.class);
thrown.expect(NameserversNotAllowedException.class);
runFlow();
}

4
javatests/google/registry/flows/domain/DomainCreateFlowTest.java
View file

@ -89,7 +89,7 @@ import google.registry.flows.domain.DomainFlowUtils.MissingAdminContactException
import google.registry.flows.domain.DomainFlowUtils.MissingContactTypeException;
import google.registry.flows.domain.DomainFlowUtils.MissingRegistrantException;
import google.registry.flows.domain.DomainFlowUtils.MissingTechnicalContactException;
import google.registry.flows.domain.DomainFlowUtils.NameserverNotAllowedException;
import google.registry.flows.domain.DomainFlowUtils.NameserversNotAllowedException;
import google.registry.flows.domain.DomainFlowUtils.NotAuthorizedForTldException;
import google.registry.flows.domain.DomainFlowUtils.PremiumNameBlockedException;
import google.registry.flows.domain.DomainFlowUtils.RegistrantNotAllowedException;
@ -1251,7 +1251,7 @@ public class DomainCreateFlowTest extends ResourceFlowTestCase<DomainCreateFlow,
persistResource(Registry.get("tld").asBuilder()
.setAllowedFullyQualifiedHostNames(ImmutableSet.of("ns2.example.net"))
.build());
thrown.expect(NameserverNotAllowedException.class, "ns1.example.net");
thrown.expect(NameserversNotAllowedException.class, "ns1.example.net");
runFlow();
}

11
javatests/google/registry/flows/domain/DomainDeleteFlowTest.java
View file

@ -60,7 +60,6 @@ import google.registry.model.billing.BillingEvent.Reason;
import google.registry.model.contact.ContactResource;
import google.registry.model.domain.DomainResource;
import google.registry.model.domain.GracePeriod;
import google.registry.model.domain.ReferenceUnion;
import google.registry.model.domain.rgp.GracePeriodStatus;
import google.registry.model.eppcommon.StatusValue;
import google.registry.model.eppcommon.Trid;
@ -118,7 +117,7 @@ public class DomainDeleteFlowTest extends ResourceFlowTestCase<DomainDeleteFlow,
ContactResource contact = persistActiveContact("sh8013");
domain = newDomainResource(getUniqueIdFromCommand()).asBuilder()
.setCreationTimeForTest(TIME_BEFORE_FLOW)
.setRegistrant(ReferenceUnion.create(contact))
.setRegistrant(Ref.create(contact))
.setRegistrationExpirationTime(expirationTime)
.build();
earlierHistoryEntry = persistResource(
@ -466,14 +465,12 @@ public class DomainDeleteFlowTest extends ResourceFlowTestCase<DomainDeleteFlow,
persistResource(loadByUniqueId(
DomainResource.class, getUniqueIdFromCommand(), clock.nowUtc())
.asBuilder()
.setNameservers(ImmutableSet.of(ReferenceUnion.create(host)))
.setNameservers(ImmutableSet.of(Ref.create(host)))
.build());
// Persist another domain that's already been deleted and references this contact and host.
persistResource(newDomainResource("example1.tld").asBuilder()
.setRegistrant(
ReferenceUnion.create(loadByUniqueId(
ContactResource.class, "sh8013", clock.nowUtc())))
.setNameservers(ImmutableSet.of(ReferenceUnion.create(host)))
.setRegistrant(Ref.create(loadByUniqueId(ContactResource.class, "sh8013", clock.nowUtc())))
.setNameservers(ImmutableSet.of(Ref.create(host)))
.setDeletionTime(START_OF_TIME)
.build());
clock.advanceOneMilli();

13
javatests/google/registry/flows/domain/DomainInfoFlowTest.java
View file

@ -44,7 +44,6 @@ import google.registry.model.domain.DesignatedContact.Type;
import google.registry.model.domain.DomainAuthInfo;
import google.registry.model.domain.DomainResource;
import google.registry.model.domain.GracePeriod;
import google.registry.model.domain.ReferenceUnion;
import google.registry.model.domain.rgp.GracePeriodStatus;
import google.registry.model.domain.secdns.DelegationSignerData;
import google.registry.model.eppcommon.AuthInfo.PasswordAuth;
@ -91,12 +90,11 @@ public class DomainInfoFlowTest extends ResourceFlowTestCase<DomainInfoFlow, Dom
.setLastEppUpdateTime(DateTime.parse("1999-12-03T09:00:00.0Z"))
.setLastTransferTime(DateTime.parse("2000-04-08T09:00:00.0Z"))
.setRegistrationExpirationTime(DateTime.parse("2005-04-03T22:00:00.0Z"))
.setRegistrant(ReferenceUnion.create(registrant))
.setRegistrant(Ref.create(registrant))
.setContacts(ImmutableSet.of(
DesignatedContact.create(Type.ADMIN, ReferenceUnion.create(contact)),
DesignatedContact.create(Type.TECH, ReferenceUnion.create(contact))))
.setNameservers(inactive ? null
: ImmutableSet.of(ReferenceUnion.create(host1), ReferenceUnion.create(host2)))
DesignatedContact.create(Type.ADMIN, Ref.create(contact)),
DesignatedContact.create(Type.TECH, Ref.create(contact))))
.setNameservers(inactive ? null : ImmutableSet.of(Ref.create(host1), Ref.create(host2)))
.setAuthInfo(DomainAuthInfo.create(PasswordAuth.create("2fooBAR")))
.build());
// Set the superordinate domain of ns1.example.com to example.com. In reality, this would have
@ -243,8 +241,7 @@ public class DomainInfoFlowTest extends ResourceFlowTestCase<DomainInfoFlow, Dom
persistResource(domain.asBuilder()
.setDsData(ImmutableSet.of(DelegationSignerData.create(
12345, 3, 1, base16().decode("49FD46E6C4B45C55D4AC"))))
.setNameservers(ImmutableSet.of(
ReferenceUnion.create(host1), ReferenceUnion.create(host3)))
.setNameservers(ImmutableSet.of(Ref.create(host1), Ref.create(host3)))
.build());
doSuccessfulTest("domain_info_response_dsdata.xml", false);
}

11
javatests/google/registry/flows/domain/DomainTransferFlowTestCase.java
View file

@ -42,7 +42,6 @@ import google.registry.model.domain.DesignatedContact.Type;
import google.registry.model.domain.DomainAuthInfo;
import google.registry.model.domain.DomainResource;
import google.registry.model.domain.GracePeriod;
import google.registry.model.domain.ReferenceUnion;
import google.registry.model.domain.rgp.GracePeriodStatus;
import google.registry.model.eppcommon.AuthInfo.PasswordAuth;
import google.registry.model.eppcommon.StatusValue;
@ -123,18 +122,14 @@ public class DomainTransferFlowTestCase<F extends Flow, R extends EppResource>
.setCreationClientId("TheRegistrar")
.setCreationTimeForTest(DateTime.parse("1999-04-03T22:00:00.0Z"))
.setRegistrationExpirationTime(REGISTRATION_EXPIRATION_TIME)
.setRegistrant(
ReferenceUnion.create(loadByUniqueId(
ContactResource.class, "jd1234", clock.nowUtc())))
.setRegistrant(Ref.create(loadByUniqueId(ContactResource.class, "jd1234", clock.nowUtc())))
.setContacts(ImmutableSet.of(
DesignatedContact.create(
Type.ADMIN,
ReferenceUnion.create(
loadByUniqueId(ContactResource.class, "jd1234", clock.nowUtc()))),
Ref.create(loadByUniqueId(ContactResource.class, "jd1234", clock.nowUtc()))),
DesignatedContact.create(
Type.TECH,
ReferenceUnion.create(
loadByUniqueId(ContactResource.class, "jd1234", clock.nowUtc())))))
Ref.create(loadByUniqueId(ContactResource.class, "jd1234", clock.nowUtc())))))
.setAuthInfo(DomainAuthInfo.create(PasswordAuth.create("fooBAR")))
.addGracePeriod(GracePeriod.create(
GracePeriodStatus.ADD, clock.nowUtc().plusDays(10), "foo", null))

59
javatests/google/registry/flows/domain/DomainUpdateFlowTest.java
View file

@ -62,7 +62,7 @@ import google.registry.flows.domain.DomainFlowUtils.LinkedResourceInPendingDelet
import google.registry.flows.domain.DomainFlowUtils.MissingAdminContactException;
import google.registry.flows.domain.DomainFlowUtils.MissingContactTypeException;
import google.registry.flows.domain.DomainFlowUtils.MissingTechnicalContactException;
import google.registry.flows.domain.DomainFlowUtils.NameserverNotAllowedException;
import google.registry.flows.domain.DomainFlowUtils.NameserversNotAllowedException;
import google.registry.flows.domain.DomainFlowUtils.NotAuthorizedForTldException;
import google.registry.flows.domain.DomainFlowUtils.RegistrantNotAllowedException;
import google.registry.flows.domain.DomainFlowUtils.TooManyDsRecordsException;
@ -74,7 +74,6 @@ import google.registry.model.domain.DesignatedContact;
import google.registry.model.domain.DesignatedContact.Type;
import google.registry.model.domain.DomainResource;
import google.registry.model.domain.GracePeriod;
import google.registry.model.domain.ReferenceUnion;
import google.registry.model.domain.rgp.GracePeriodStatus;
import google.registry.model.domain.secdns.DelegationSignerData;
import google.registry.model.eppcommon.StatusValue;
@ -123,9 +122,9 @@ public class DomainUpdateFlowTest extends ResourceFlowTestCase<DomainUpdateFlow,
DomainResource domain = persistResource(
newDomainResource(getUniqueIdFromCommand()).asBuilder()
.setContacts(ImmutableSet.of(
DesignatedContact.create(Type.TECH, ReferenceUnion.create(sh8013Contact)),
DesignatedContact.create(Type.ADMIN, ReferenceUnion.create(unusedContact))))
.setNameservers(ImmutableSet.of(ReferenceUnion.create(host)))
DesignatedContact.create(Type.TECH, Ref.create(sh8013Contact)),
DesignatedContact.create(Type.ADMIN, Ref.create(unusedContact))))
.setNameservers(ImmutableSet.of(Ref.create(host)))
.build());
historyEntryDomainCreate = persistResource(
new HistoryEntry.Builder()
@ -180,7 +179,7 @@ public class DomainUpdateFlowTest extends ResourceFlowTestCase<DomainUpdateFlow,
HistoryEntry historyEntryDomainUpdate =
getOnlyHistoryEntryOfType(resource, HistoryEntry.Type.DOMAIN_UPDATE);
assertThat(resource.getNameservers()).containsExactly(
ReferenceUnion.create(
Ref.create(
loadByUniqueId(HostResource.class, "ns2.example.foo", clock.nowUtc())));
BillingEvent.OneTime regularAddBillingEvent = new BillingEvent.OneTime.Builder()
.setReason(Reason.CREATE)
@ -278,7 +277,7 @@ public class DomainUpdateFlowTest extends ResourceFlowTestCase<DomainUpdateFlow,
// serverHold on it.
persistResource(
reloadResourceByUniqueId().asBuilder()
.setNameservers(ImmutableSet.of(ReferenceUnion.create(
.setNameservers(ImmutableSet.of(Ref.create(
loadByUniqueId(HostResource.class, "ns2.example.foo", clock.nowUtc()))))
.addGracePeriod(GracePeriod.forBillingEvent(
GracePeriodStatus.SUNRUSH_ADD, sunrushAddBillingEvent))
@ -302,7 +301,7 @@ public class DomainUpdateFlowTest extends ResourceFlowTestCase<DomainUpdateFlow,
// serverHold on it.
persistResource(
reloadResourceByUniqueId().asBuilder()
.setNameservers(ImmutableSet.of(ReferenceUnion.create(
.setNameservers(ImmutableSet.of(Ref.create(
loadByUniqueId(HostResource.class, "ns2.example.foo", clock.nowUtc()))))
.addGracePeriod(GracePeriod.forBillingEvent(
GracePeriodStatus.SUNRUSH_ADD, sunrushAddBillingEvent))
@ -345,10 +344,10 @@ public class DomainUpdateFlowTest extends ResourceFlowTestCase<DomainUpdateFlow,
}
private void modifyDomainToHave13Nameservers() throws Exception {
ImmutableSet.Builder<ReferenceUnion<HostResource>> nameservers = new ImmutableSet.Builder<>();
ImmutableSet.Builder<Ref<HostResource>> nameservers = new ImmutableSet.Builder<>();
for (int i = 1; i < 15; i++) {
if (i != 2) { // Skip 2 since that's the one that the tests will add.
nameservers.add(ReferenceUnion.create(loadByUniqueId(
nameservers.add(Ref.create(loadByUniqueId(
HostResource.class, String.format("ns%d.example.foo", i), clock.nowUtc())));
}
}
@ -374,11 +373,11 @@ public class DomainUpdateFlowTest extends ResourceFlowTestCase<DomainUpdateFlow,
persistDomain();
setEppInput("domain_update_max_everything.xml");
// Create 26 hosts and 8 contacts. Start the domain with half of them.
ImmutableSet.Builder<ReferenceUnion<HostResource>> nameservers = new ImmutableSet.Builder<>();
ImmutableSet.Builder<Ref<HostResource>> nameservers = new ImmutableSet.Builder<>();
for (int i = 0; i < 26; i++) {
HostResource host = persistActiveHost(String.format("max_test_%d.example.tld", i));
if (i < 13) {
nameservers.add(ReferenceUnion.create(host));
nameservers.add(Ref.create(host));
}
}
ImmutableSet.Builder<DesignatedContact> contacts = new ImmutableSet.Builder<>();
@ -388,7 +387,7 @@ public class DomainUpdateFlowTest extends ResourceFlowTestCase<DomainUpdateFlow,
contacts.add(
DesignatedContact.create(
DesignatedContact.Type.values()[i],
ReferenceUnion.create(contact)));
Ref.create(contact)));
}
}
persistResource(
@ -407,7 +406,7 @@ public class DomainUpdateFlowTest extends ResourceFlowTestCase<DomainUpdateFlow,
assertThat(domain.getNameservers()).hasSize(13);
// getContacts does not return contacts of type REGISTRANT, so check these separately.
assertThat(domain.getContacts()).hasSize(3);
assertThat(domain.getRegistrant().getLinked().get().getContactId()).isEqualTo("max_test_7");
assertThat(domain.getRegistrant().get().getContactId()).isEqualTo("max_test_7");
assertNoBillingEvents();
assertDnsTasksEnqueued("example.tld");
}
@ -459,14 +458,14 @@ public class DomainUpdateFlowTest extends ResourceFlowTestCase<DomainUpdateFlow,
domain = persistResource(domain.asBuilder()
.addSubordinateHost("ns1.example.tld")
.addSubordinateHost("ns2.example.tld")
.setNameservers(ImmutableSet.of(ReferenceUnion.create(
.setNameservers(ImmutableSet.of(Ref.create(
loadByUniqueId(HostResource.class, "ns1.example.tld", clock.nowUtc()))))
.build());
clock.advanceOneMilli();
assertTransactionalFlow(true);
runFlowAssertResponse(readFile("domain_update_response.xml"));
domain = reloadResourceByUniqueId();
assertThat(domain.getNameservers()).containsExactly(ReferenceUnion.create(addedHost));
assertThat(domain.getNameservers()).containsExactly(Ref.create(addedHost));
assertThat(domain.getSubordinateHosts()).containsExactly("ns1.example.tld", "ns2.example.tld");
existingHost = loadByUniqueId(HostResource.class, "ns1.example.tld", clock.nowUtc());
addedHost = loadByUniqueId(HostResource.class, "ns2.example.tld", clock.nowUtc());
@ -481,7 +480,7 @@ public class DomainUpdateFlowTest extends ResourceFlowTestCase<DomainUpdateFlow,
ContactResource sh8013 = loadByUniqueId(ContactResource.class, "sh8013", clock.nowUtc());
persistResource(
newDomainResource(getUniqueIdFromCommand()).asBuilder()
.setRegistrant(ReferenceUnion.create(sh8013))
.setRegistrant(Ref.create(sh8013))
.build());
clock.advanceOneMilli();
runFlowAssertResponse(readFile("domain_update_response.xml"));
@ -492,14 +491,14 @@ public class DomainUpdateFlowTest extends ResourceFlowTestCase<DomainUpdateFlow,
setEppInput("domain_update_remove_multiple_contacts.xml");
persistReferencedEntities();
ContactResource sh8013 = loadByUniqueId(ContactResource.class, "sh8013", clock.nowUtc());
ReferenceUnion<ContactResource> sh8013ReferenceUnion = ReferenceUnion.create(sh8013);
Ref<ContactResource> sh8013Ref = Ref.create(sh8013);
persistResource(
newDomainResource(getUniqueIdFromCommand()).asBuilder()
.setRegistrant(sh8013ReferenceUnion)
.setRegistrant(sh8013Ref)
.setContacts(ImmutableSet.of(
DesignatedContact.create(Type.ADMIN, sh8013ReferenceUnion),
DesignatedContact.create(Type.BILLING, sh8013ReferenceUnion),
DesignatedContact.create(Type.TECH, sh8013ReferenceUnion)))
DesignatedContact.create(Type.ADMIN, sh8013Ref),
DesignatedContact.create(Type.BILLING, sh8013Ref),
DesignatedContact.create(Type.TECH, sh8013Ref)))
.build());
clock.advanceOneMilli();
runFlowAssertResponse(readFile("domain_update_response.xml"));
@ -891,7 +890,7 @@ public class DomainUpdateFlowTest extends ResourceFlowTestCase<DomainUpdateFlow,
persistResource(
reloadResourceByUniqueId().asBuilder()
.setContacts(ImmutableSet.of(
DesignatedContact.create(Type.TECH, ReferenceUnion.create(
DesignatedContact.create(Type.TECH, Ref.create(
loadByUniqueId(ContactResource.class, "foo", clock.nowUtc())))))
.build());
runFlow();
@ -988,7 +987,7 @@ public class DomainUpdateFlowTest extends ResourceFlowTestCase<DomainUpdateFlow,
persistReferencedEntities();
persistResource(
newDomainResource(getUniqueIdFromCommand()).asBuilder()
.setNameservers(ImmutableSet.of(ReferenceUnion.create(
.setNameservers(ImmutableSet.of(Ref.create(
loadByUniqueId(HostResource.class, "ns1.example.foo", clock.nowUtc()))))
.build());
runFlow();
@ -1003,7 +1002,7 @@ public class DomainUpdateFlowTest extends ResourceFlowTestCase<DomainUpdateFlow,
newDomainResource(getUniqueIdFromCommand()).asBuilder()
.setContacts(ImmutableSet.of(DesignatedContact.create(
Type.TECH,
ReferenceUnion.create(
Ref.create(
loadByUniqueId(ContactResource.class, "sh8013", clock.nowUtc())))))
.build());
runFlow();
@ -1017,8 +1016,8 @@ public class DomainUpdateFlowTest extends ResourceFlowTestCase<DomainUpdateFlow,
persistResource(
newDomainResource(getUniqueIdFromCommand()).asBuilder()
.setContacts(ImmutableSet.of(
DesignatedContact.create(Type.ADMIN, ReferenceUnion.create(sh8013Contact)),
DesignatedContact.create(Type.TECH, ReferenceUnion.create(sh8013Contact))))
DesignatedContact.create(Type.ADMIN, Ref.create(sh8013Contact)),
DesignatedContact.create(Type.TECH, Ref.create(sh8013Contact))))
.build());
runFlow();
}
@ -1031,8 +1030,8 @@ public class DomainUpdateFlowTest extends ResourceFlowTestCase<DomainUpdateFlow,
persistResource(
newDomainResource(getUniqueIdFromCommand()).asBuilder()
.setContacts(ImmutableSet.of(
DesignatedContact.create(Type.ADMIN, ReferenceUnion.create(sh8013Contact)),
DesignatedContact.create(Type.TECH, ReferenceUnion.create(sh8013Contact))))
DesignatedContact.create(Type.ADMIN, Ref.create(sh8013Contact)),
DesignatedContact.create(Type.TECH, Ref.create(sh8013Contact))))
.build());
runFlow();
}
@ -1094,7 +1093,7 @@ public class DomainUpdateFlowTest extends ResourceFlowTestCase<DomainUpdateFlow,
.setAllowedFullyQualifiedHostNames(ImmutableSet.of("ns1.example.foo"))
.build());
clock.advanceOneMilli();
thrown.expect(NameserverNotAllowedException.class);
thrown.expect(NameserversNotAllowedException.class);
runFlow();
}

6
javatests/google/registry/flows/host/HostDeleteFlowTest.java
View file

@ -31,6 +31,7 @@ import static google.registry.testing.TaskQueueHelper.assertTasksEnqueued;
import com.google.common.collect.ImmutableSet;
import com.googlecode.objectify.Key;
import com.googlecode.objectify.Ref;
import google.registry.flows.FlowRunner.CommitMode;
import google.registry.flows.FlowRunner.UserPrivileges;
@ -41,7 +42,6 @@ import google.registry.flows.ResourceMutateFlow.ResourceToMutateDoesNotExistExce
import google.registry.flows.SingleResourceFlow.ResourceStatusProhibitsOperationException;
import google.registry.flows.async.DeleteEppResourceAction;
import google.registry.flows.async.DeleteHostResourceAction;
import google.registry.model.domain.ReferenceUnion;
import google.registry.model.eppcommon.StatusValue;
import google.registry.model.host.HostResource;
import google.registry.model.reporting.HistoryEntry;
@ -179,7 +179,7 @@ public class HostDeleteFlowTest extends ResourceFlowTestCase<HostDeleteFlow, Hos
createTld("tld");
persistResource(newDomainResource("example.tld").asBuilder()
.setNameservers(ImmutableSet.of(
ReferenceUnion.create(persistActiveHost(getUniqueIdFromCommand()))))
Ref.create(persistActiveHost(getUniqueIdFromCommand()))))
.build());
thrown.expect(ResourceToDeleteIsReferencedException.class);
runFlow();
@ -190,7 +190,7 @@ public class HostDeleteFlowTest extends ResourceFlowTestCase<HostDeleteFlow, Hos
createTld("tld");
persistResource(newDomainApplication("example.tld").asBuilder()
.setNameservers(ImmutableSet.of(
ReferenceUnion.create(persistActiveHost(getUniqueIdFromCommand()))))
Ref.create(persistActiveHost(getUniqueIdFromCommand()))))
.build());
thrown.expect(ResourceToDeleteIsReferencedException.class);
runFlow();

3
javatests/google/registry/flows/host/HostInfoFlowTest.java
View file

@ -29,7 +29,6 @@ import com.googlecode.objectify.Ref;
import google.registry.flows.ResourceFlowTestCase;
import google.registry.flows.ResourceQueryFlow.ResourceToQueryDoesNotExistException;
import google.registry.model.domain.DomainResource;
import google.registry.model.domain.ReferenceUnion;
import google.registry.model.eppcommon.StatusValue;
import google.registry.model.host.HostResource;
@ -94,7 +93,7 @@ public class HostInfoFlowTest extends ResourceFlowTestCase<HostInfoFlow, HostRes
persistResource(
newDomainResource("example.foobar").asBuilder()
.addNameservers(
ImmutableSet.of(ReferenceUnion.<HostResource>create(persistHostResource(true))))
ImmutableSet.of(Ref.<HostResource>create(persistHostResource(true))))
.build());
assertTransactionalFlow(false);
// Check that the persisted host info was returned.

3
javatests/google/registry/flows/host/HostUpdateFlowTest.java
View file

@ -58,7 +58,6 @@ import google.registry.flows.host.HostUpdateFlow.HostAlreadyExistsException;
import google.registry.flows.host.HostUpdateFlow.RenameHostToExternalRemoveIpException;
import google.registry.flows.host.HostUpdateFlow.RenameHostToSubordinateRequiresIpException;
import google.registry.model.domain.DomainResource;
import google.registry.model.domain.ReferenceUnion;
import google.registry.model.eppcommon.StatusValue;
import google.registry.model.host.HostResource;
import google.registry.model.index.ForeignKeyIndex;
@ -162,7 +161,7 @@ public class HostUpdateFlowTest extends ResourceFlowTestCase<HostUpdateFlow, Hos
persistResource(
newDomainResource("test.xn--q9jyb4c").asBuilder()
.setDeletionTime(END_OF_TIME)
.setNameservers(ImmutableSet.of(ReferenceUnion.create(host)))
.setNameservers(ImmutableSet.of(Ref.create(host)))
.build());
HostResource renamedHost = doSuccessfulTest();
assertThat(renamedHost.getSuperordinateDomain()).isNull();

12
javatests/google/registry/model/domain/DomainApplicationTest.java
View file

@ -19,6 +19,7 @@ import static google.registry.model.EppResourceUtils.loadByUniqueId;
import static google.registry.testing.DatastoreHelper.cloneAndSetAutoTimestamps;
import static google.registry.testing.DatastoreHelper.createTld;
import static google.registry.testing.DatastoreHelper.newDomainApplication;
import static google.registry.testing.DatastoreHelper.newHostResource;
import static google.registry.testing.DatastoreHelper.persistActiveContact;
import static google.registry.testing.DatastoreHelper.persistActiveHost;
import static google.registry.testing.DatastoreHelper.persistResource;
@ -29,6 +30,7 @@ import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
import com.googlecode.objectify.Key;
import com.googlecode.objectify.Ref;
import google.registry.model.EntityTestCase;
import google.registry.model.billing.BillingEvent;
@ -78,12 +80,12 @@ public class DomainApplicationTest extends EntityTestCase {
StatusValue.SERVER_UPDATE_PROHIBITED,
StatusValue.SERVER_RENEW_PROHIBITED,
StatusValue.SERVER_HOLD))
.setRegistrant(ReferenceUnion.create(persistActiveContact("contact_id1")))
.setRegistrant(Ref.create(persistActiveContact("contact_id1")))
.setContacts(ImmutableSet.of(DesignatedContact.create(
DesignatedContact.Type.ADMIN,
ReferenceUnion.create(persistActiveContact("contact_id2")))))
Ref.create(persistActiveContact("contact_id2")))))
.setNameservers(
ImmutableSet.of(ReferenceUnion.create(persistActiveHost("ns1.example.com"))))
ImmutableSet.of(Ref.create(persistActiveHost("ns1.example.com"))))
.setCurrentSponsorClientId("a third registrar")
.setAuthInfo(DomainAuthInfo.create(PasswordAuth.create("password")))
.setDsData(ImmutableSet.of(DelegationSignerData.create(1, 2, 3, new byte[] {0, 1, 2})))
@ -149,12 +151,12 @@ public class DomainApplicationTest extends EntityTestCase {
public void testEmptySetsAndArraysBecomeNull() {
assertThat(emptyBuilder().setNameservers(null).build().nameservers).isNull();
assertThat(emptyBuilder()
.setNameservers(ImmutableSet.<ReferenceUnion<HostResource>>of())
.setNameservers(ImmutableSet.<Ref<HostResource>>of())
.build()
.nameservers)
.isNull();
assertThat(emptyBuilder()
.setNameservers(ImmutableSet.of(ReferenceUnion.<HostResource>create("foo")))
.setNameservers(ImmutableSet.of(Ref.create(newHostResource("foo.example.tld"))))
.build()
.nameservers)
.isNotNull();

15
javatests/google/registry/model/domain/DomainResourceTest.java
View file

@ -20,6 +20,7 @@ import static google.registry.model.EppResourceUtils.loadByUniqueId;
import static google.registry.testing.DatastoreHelper.cloneAndSetAutoTimestamps;
import static google.registry.testing.DatastoreHelper.createTld;
import static google.registry.testing.DatastoreHelper.newDomainResource;
import static google.registry.testing.DatastoreHelper.newHostResource;
import static google.registry.testing.DatastoreHelper.persistResource;
import static google.registry.testing.DomainResourceSubject.assertAboutDomains;
import static google.registry.util.DateTimeUtils.START_OF_TIME;
@ -103,11 +104,11 @@ public class DomainResourceTest extends EntityTestCase {
StatusValue.SERVER_UPDATE_PROHIBITED,
StatusValue.SERVER_RENEW_PROHIBITED,
StatusValue.SERVER_HOLD))
.setRegistrant(ReferenceUnion.create(contactResource1))
.setRegistrant(Ref.create(contactResource1))
.setContacts(ImmutableSet.of(DesignatedContact.create(
DesignatedContact.Type.ADMIN,
ReferenceUnion.create(contactResource2))))
.setNameservers(ImmutableSet.of(ReferenceUnion.create(hostResource)))
Ref.create(contactResource2))))
.setNameservers(ImmutableSet.of(Ref.create(hostResource)))
.setSubordinateHosts(ImmutableSet.of("ns1.example.com"))
.setCurrentSponsorClientId("a third registrar")
.setRegistrationExpirationTime(clock.nowUtc().plusYears(1))
@ -190,10 +191,10 @@ public class DomainResourceTest extends EntityTestCase {
assertThat(newDomainResource("example.com").asBuilder()
.setNameservers(null).build().nameservers).isNull();
assertThat(newDomainResource("example.com").asBuilder()
.setNameservers(ImmutableSet.<ReferenceUnion<HostResource>>of()).build().nameservers)
.setNameservers(ImmutableSet.<Ref<HostResource>>of()).build().nameservers)
.isNull();
assertThat(newDomainResource("example.com").asBuilder()
.setNameservers(ImmutableSet.of(ReferenceUnion.<HostResource>create("foo")))
.setNameservers(ImmutableSet.of(Ref.create(newHostResource("foo.example.tld"))))
.build().nameservers)
.isNotNull();
// This behavior should also hold true for ImmutableObjects nested in collections.
@ -222,8 +223,8 @@ public class DomainResourceTest extends EntityTestCase {
@Test
public void testImplicitStatusValues() {
ImmutableSet<ReferenceUnion<HostResource>> nameservers =
ImmutableSet.of(ReferenceUnion.<HostResource>create("foo"));
ImmutableSet<Ref<HostResource>> nameservers =
ImmutableSet.of(Ref.create(newHostResource("foo.example.tld")));
StatusValue[] statuses = {StatusValue.OK};
// OK is implicit if there's no other statuses but there are nameservers.
assertAboutDomains()

7
javatests/google/registry/monitoring/whitebox/VerifyEntityIntegrityActionTest.java
View file

@ -49,7 +49,6 @@ import google.registry.config.RegistryEnvironment;
import google.registry.mapreduce.MapreduceRunner;
import google.registry.model.contact.ContactResource;
import google.registry.model.domain.DomainResource;
import google.registry.model.domain.ReferenceUnion;
import google.registry.model.host.HostResource;
import google.registry.model.index.EppResourceIndex;
import google.registry.model.index.ForeignKeyIndex;
@ -192,9 +191,9 @@ public class VerifyEntityIntegrityActionTest
.asBuilder()
.setNameservers(
ImmutableSet.of(
ReferenceUnion.create(Ref.create(missingHost1)),
ReferenceUnion.create(Ref.create(missingHost2)),
ReferenceUnion.create(Ref.create(missingHost3))))
Ref.create(missingHost1),
Ref.create(missingHost2),
Ref.create(missingHost3)))
.build());
String source = Key.create(domain).toString();
runMapreduce();

1
javatests/google/registry/pricing/PricingEngineProxyTest.java
View file

@ -25,6 +25,7 @@ import static google.registry.util.DateTimeUtils.START_OF_TIME;
import static org.joda.money.CurrencyUnit.USD;
import com.google.common.collect.ImmutableSortedMap;
import google.registry.model.registry.Registry;
import google.registry.model.registry.label.PremiumList;
import google.registry.testing.AppEngineRule;

11
javatests/google/registry/rde/DomainResourceToXjcConverterTest.java
View file

@ -46,7 +46,6 @@ import google.registry.model.domain.DesignatedContact;
import google.registry.model.domain.DomainAuthInfo;
import google.registry.model.domain.DomainResource;
import google.registry.model.domain.GracePeriod;
import google.registry.model.domain.ReferenceUnion;
import google.registry.model.domain.rgp.GracePeriodStatus;
import google.registry.model.domain.secdns.DelegationSignerData;
import google.registry.model.eppcommon.AuthInfo.PasswordAuth;
@ -264,10 +263,10 @@ public class DomainResourceToXjcConverterTest {
domain = domain.asBuilder()
.setAuthInfo(DomainAuthInfo.create(PasswordAuth.create("secret")))
.setContacts(ImmutableSet.of(
DesignatedContact.create(DesignatedContact.Type.ADMIN, ReferenceUnion.create(
DesignatedContact.create(DesignatedContact.Type.ADMIN, Ref.create(
makeContactResource(clock, "10-Q9JYB4C", "5372808-IRL",
"be that word our sign in parting", "BOFH@cat.みんな"))),
DesignatedContact.create(DesignatedContact.Type.TECH, ReferenceUnion.create(
DesignatedContact.create(DesignatedContact.Type.TECH, Ref.create(
makeContactResource(clock, "11-Q9JYB4C", "5372808-TRL",
"bird or fiend!? i shrieked upstarting", "bog@cat.みんな")))))
.setCreationClientId("LawyerCat")
@ -280,11 +279,11 @@ public class DomainResourceToXjcConverterTest {
.setLastEppUpdateClientId("IntoTheTempest")
.setLastEppUpdateTime(DateTime.parse("1920-01-01T00:00:00Z"))
.setNameservers(ImmutableSet.of(
ReferenceUnion.create(
Ref.create(
makeHostResource(clock, "3-Q9JYB4C", "bird.or.devil.みんな", "1.2.3.4")),
ReferenceUnion.create(
Ref.create(
makeHostResource(clock, "4-Q9JYB4C", "ns2.cat.みんな", "bad:f00d:cafe::15:beef"))))
.setRegistrant(ReferenceUnion.create(makeContactResource(
.setRegistrant(Ref.create(makeContactResource(
clock, "12-Q9JYB4C", "5372808-ERL", "(◕‿◕) nevermore", "prophet@evil.みんな")))
.setRegistrationExpirationTime(DateTime.parse("1930-01-01T00:00:00Z"))
.setGracePeriods(ImmutableSet.of(

11
javatests/google/registry/rde/RdeFixtures.java
View file

@ -41,7 +41,6 @@ import google.registry.model.domain.DesignatedContact;
import google.registry.model.domain.DomainAuthInfo;
import google.registry.model.domain.DomainResource;
import google.registry.model.domain.GracePeriod;
import google.registry.model.domain.ReferenceUnion;
import google.registry.model.domain.rgp.GracePeriodStatus;
import google.registry.model.domain.secdns.DelegationSignerData;
import google.registry.model.eppcommon.AuthInfo.PasswordAuth;
@ -85,10 +84,10 @@ final class RdeFixtures {
domain = domain.asBuilder()
.setAuthInfo(DomainAuthInfo.create(PasswordAuth.create("secret")))
.setContacts(ImmutableSet.of(
DesignatedContact.create(DesignatedContact.Type.ADMIN, ReferenceUnion.create(
DesignatedContact.create(DesignatedContact.Type.ADMIN, Ref.create(
makeContactResource(clock, "5372808-IRL",
"be that word our sign in parting", "BOFH@cat.みんな"))),
DesignatedContact.create(DesignatedContact.Type.TECH, ReferenceUnion.create(
DesignatedContact.create(DesignatedContact.Type.TECH, Ref.create(
makeContactResource(clock, "5372808-TRL",
"bird or fiend!? i shrieked upstarting", "bog@cat.みんな")))))
.setCreationClientId("TheRegistrar")
@ -102,12 +101,12 @@ final class RdeFixtures {
.setLastEppUpdateTime(clock.nowUtc())
.setIdnTableName("extended_latin")
.setNameservers(ImmutableSet.of(
ReferenceUnion.create(
Ref.create(
makeHostResource(clock, "bird.or.devil.みんな", "1.2.3.4")),
ReferenceUnion.create(
Ref.create(
makeHostResource(
clock, "ns2.cat.みんな", "bad:f00d:cafe::15:beef"))))
.setRegistrant(ReferenceUnion.create(
.setRegistrant(Ref.create(
makeContactResource(clock,
"5372808-ERL", "(◕‿◕) nevermore", "prophet@evil.みんな")))
.setRegistrationExpirationTime(DateTime.parse("1930-01-01T00:00:00Z"))

1
javatests/google/registry/server/BUILD
View file

@ -38,6 +38,7 @@ java_library(
"//java/com/google/common/collect",
"//third_party/java/appengine:appengine-api",
"//third_party/java/joda_time",
"//third_party/java/objectify:objectify-v4_1",
"//java/google/registry/model",
"//javatests/google/registry/testing",
],

31
javatests/google/registry/server/Fixture.java
View file

@ -26,11 +26,12 @@ import static google.registry.testing.DatastoreHelper.persistResource;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
import com.googlecode.objectify.Ref;
import google.registry.model.contact.ContactAddress;
import google.registry.model.contact.ContactResource;
import google.registry.model.contact.PostalInfo;
import google.registry.model.domain.DesignatedContact;
import google.registry.model.domain.ReferenceUnion;
import google.registry.model.ofy.Ofy;
import google.registry.model.registrar.Registrar;
import google.registry.testing.FakeClock;
@ -114,28 +115,26 @@ public enum Fixture {
persistResource(
newDomainResource("love.xn--q9jyb4c", justine).asBuilder()
.setContacts(ImmutableSet.of(
DesignatedContact.create(ADMIN, ReferenceUnion.create(robert)),
DesignatedContact.create(BILLING, ReferenceUnion.create(google)),
DesignatedContact.create(TECH, ReferenceUnion.create(justine))))
DesignatedContact.create(ADMIN, Ref.create(robert)),
DesignatedContact.create(BILLING, Ref.create(google)),
DesignatedContact.create(TECH, Ref.create(justine))))
.setNameservers(ImmutableSet.of(
ReferenceUnion.create(
persistActiveHost("ns1.love.xn--q9jyb4c")),
ReferenceUnion.create(
persistActiveHost("ns2.love.xn--q9jyb4c"))))
Ref.create(persistActiveHost("ns1.love.xn--q9jyb4c")),
Ref.create(persistActiveHost("ns2.love.xn--q9jyb4c"))))
.build());
persistResource(
newDomainResource("moogle.example", justine).asBuilder()
.setContacts(ImmutableSet.of(
DesignatedContact.create(ADMIN, ReferenceUnion.create(robert)),
DesignatedContact.create(BILLING, ReferenceUnion.create(google)),
DesignatedContact.create(TECH, ReferenceUnion.create(justine))))
DesignatedContact.create(ADMIN, Ref.create(robert)),
DesignatedContact.create(BILLING, Ref.create(google)),
DesignatedContact.create(TECH, Ref.create(justine))))
.setNameservers(ImmutableSet.of(
ReferenceUnion.create(persistActiveHost("ns1.linode.com")),
ReferenceUnion.create(persistActiveHost("ns2.linode.com")),
ReferenceUnion.create(persistActiveHost("ns3.linode.com")),
ReferenceUnion.create(persistActiveHost("ns4.linode.com")),
ReferenceUnion.create(persistActiveHost("ns5.linode.com"))))
Ref.create(persistActiveHost("ns1.linode.com")),
Ref.create(persistActiveHost("ns2.linode.com")),
Ref.create(persistActiveHost("ns3.linode.com")),
Ref.create(persistActiveHost("ns4.linode.com")),
Ref.create(persistActiveHost("ns5.linode.com"))))
.build());
persistResource(

15
javatests/google/registry/testing/DatastoreHelper.java
View file

@ -68,7 +68,6 @@ import google.registry.model.domain.DesignatedContact.Type;
import google.registry.model.domain.DomainApplication;
import google.registry.model.domain.DomainAuthInfo;
import google.registry.model.domain.DomainResource;
import google.registry.model.domain.ReferenceUnion;
import google.registry.model.domain.launch.LaunchPhase;
import google.registry.model.eppcommon.AuthInfo.PasswordAuth;
import google.registry.model.eppcommon.StatusValue;
@ -132,6 +131,7 @@ public class DatastoreHelper {
public static DomainResource newDomainResource(
String domainName, String repoId, ContactResource contact) {
Ref<ContactResource> contactRef = Ref.create(contact);
return new DomainResource.Builder()
.setRepoId(repoId)
.setFullyQualifiedDomainName(domainName)
@ -139,10 +139,10 @@ public class DatastoreHelper {
.setCurrentSponsorClientId("TheRegistrar")
.setCreationTimeForTest(START_OF_TIME)
.setAuthInfo(DomainAuthInfo.create(PasswordAuth.create("2fooBAR")))
.setRegistrant(ReferenceUnion.create(contact))
.setRegistrant(contactRef)
.setContacts(ImmutableSet.of(
DesignatedContact.create(Type.ADMIN, ReferenceUnion.create(contact)),
DesignatedContact.create(Type.TECH, ReferenceUnion.create(contact))))
DesignatedContact.create(Type.ADMIN, contactRef),
DesignatedContact.create(Type.TECH, contactRef)))
.setRegistrationExpirationTime(END_OF_TIME)
.build();
}
@ -172,15 +172,16 @@ public class DatastoreHelper {
public static DomainApplication newDomainApplication(
String domainName, String repoId, ContactResource contact, LaunchPhase phase) {
Ref<ContactResource> contactRef = Ref.create(contact);
return new DomainApplication.Builder()
.setRepoId(repoId)
.setFullyQualifiedDomainName(domainName)
.setCurrentSponsorClientId("TheRegistrar")
.setAuthInfo(DomainAuthInfo.create(PasswordAuth.create("2fooBAR")))
.setRegistrant(ReferenceUnion.create(contact))
.setRegistrant(contactRef)
.setContacts(ImmutableSet.of(
DesignatedContact.create(Type.ADMIN, ReferenceUnion.create(contact)),
DesignatedContact.create(Type.TECH, ReferenceUnion.create(contact))))
DesignatedContact.create(Type.ADMIN, contactRef),
DesignatedContact.create(Type.TECH, contactRef)))
.setPhase(phase)
.setApplicationStatus(VALIDATED)
.addStatusValue(StatusValue.PENDING_CREATE)

15
javatests/google/registry/testing/FullFieldsTestEntityHelper.java
View file

@ -24,6 +24,8 @@ import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
import com.google.common.net.InetAddresses;
import com.googlecode.objectify.Ref;
import google.registry.model.EppResource;
import google.registry.model.contact.ContactAddress;
import google.registry.model.contact.ContactPhoneNumber;
@ -32,7 +34,6 @@ import google.registry.model.contact.PostalInfo;
import google.registry.model.domain.DesignatedContact;
import google.registry.model.domain.DomainResource;
import google.registry.model.domain.Period;
import google.registry.model.domain.ReferenceUnion;
import google.registry.model.domain.secdns.DelegationSignerData;
import google.registry.model.eppcommon.StatusValue;
import google.registry.model.eppcommon.Trid;
@ -232,27 +233,27 @@ public final class FullFieldsTestEntityHelper {
StatusValue.SERVER_UPDATE_PROHIBITED))
.setDsData(ImmutableSet.of(new DelegationSignerData()));
if (registrant != null) {
builder.setRegistrant(ReferenceUnion.create(registrant));
builder.setRegistrant(Ref.create(registrant));
}
if ((admin != null) || (tech != null)) {
ImmutableSet.Builder<DesignatedContact> contactsBuilder = new ImmutableSet.Builder<>();
if (admin != null) {
contactsBuilder.add(DesignatedContact.create(
DesignatedContact.Type.ADMIN, ReferenceUnion.create(admin)));
DesignatedContact.Type.ADMIN, Ref.create(admin)));
}
if (tech != null) {
contactsBuilder.add(DesignatedContact.create(
DesignatedContact.Type.TECH, ReferenceUnion.create(tech)));
DesignatedContact.Type.TECH, Ref.create(tech)));
}
builder.setContacts(contactsBuilder.build());
}
if ((ns1 != null) || (ns2 != null)) {
ImmutableSet.Builder<ReferenceUnion<HostResource>> nsBuilder = new ImmutableSet.Builder<>();
ImmutableSet.Builder<Ref<HostResource>> nsBuilder = new ImmutableSet.Builder<>();
if (ns1 != null) {
nsBuilder.add(ReferenceUnion.create(ns1));
nsBuilder.add(Ref.create(ns1));
}
if (ns2 != null) {
nsBuilder.add(ReferenceUnion.create(ns2));
nsBuilder.add(Ref.create(ns2));
}
builder.setNameservers(nsBuilder.build());
}

14
javatests/google/registry/tools/AllocateDomainCommandTest.java
View file

@ -42,12 +42,12 @@ import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
import com.beust.jcommander.ParameterException;
import com.googlecode.objectify.Ref;
import google.registry.flows.EppXmlTransformer;
import google.registry.flows.domain.DomainAllocateFlow;
import google.registry.model.domain.DesignatedContact;
import google.registry.model.domain.DomainApplication;
import google.registry.model.domain.ReferenceUnion;
import google.registry.model.domain.launch.LaunchNotice;
import google.registry.model.domain.secdns.DelegationSignerData;
import google.registry.model.eppcommon.Trid;
@ -93,20 +93,20 @@ public class AllocateDomainCommandTest extends CommandTestCase<AllocateDomainCom
.asBuilder()
.setRepoId(repoId)
.setCreationTimeForTest(START_OF_TIME)
.setRegistrant(ReferenceUnion.create(persistActiveContact("registrant")))
.setRegistrant(Ref.create(persistActiveContact("registrant")))
.setContacts(ImmutableSet.of(
DesignatedContact.create(
ADMIN,
ReferenceUnion.create(persistActiveContact("adminContact"))),
Ref.create(persistActiveContact("adminContact"))),
DesignatedContact.create(
BILLING,
ReferenceUnion.create(persistActiveContact("billingContact"))),
Ref.create(persistActiveContact("billingContact"))),
DesignatedContact.create(
TECH,
ReferenceUnion.create(persistActiveContact("techContact")))))
Ref.create(persistActiveContact("techContact")))))
.setNameservers(ImmutableSet.of(
ReferenceUnion.create(persistActiveHost("ns1.example.com")),
ReferenceUnion.create(persistActiveHost("ns2.example.com"))))
Ref.create(persistActiveHost("ns1.example.com")),
Ref.create(persistActiveHost("ns2.example.com"))))
.setApplicationStatus(VALIDATED)
.setDsData(ImmutableSet.of(
DelegationSignerData.create(

9
javatests/google/registry/tools/GenerateDnsReportCommandTest.java
View file

@ -34,7 +34,6 @@ import com.beust.jcommander.ParameterException;
import com.googlecode.objectify.Ref;
import google.registry.model.domain.DomainResource;
import google.registry.model.domain.ReferenceUnion;
import google.registry.model.domain.secdns.DelegationSignerData;
import google.registry.model.eppcommon.StatusValue;
import google.registry.model.host.HostResource;
@ -135,17 +134,13 @@ public class GenerateDnsReportCommandTest extends CommandTestCase<GenerateDnsRep
nameserver3 = persistActiveHost("ns1.google.com");
nameserver4 = persistActiveHost("ns2.google.com");
domain1 = persistResource(newDomainResource("example.xn--q9jyb4c").asBuilder()
.setNameservers(ImmutableSet.of(
ReferenceUnion.create(Ref.create(nameserver1)),
ReferenceUnion.create(Ref.create(nameserver2))))
.setNameservers(ImmutableSet.of(Ref.create(nameserver1), Ref.create(nameserver2)))
.setDsData(ImmutableSet.of(
DelegationSignerData.create(12345, 3, 1, base16().decode("49FD46E6C4B45C55D4AC")),
DelegationSignerData.create(56789, 2, 4, base16().decode("69FD46E6C4A45C55D4AC"))))
.build());
persistResource(newDomainResource("foobar.xn--q9jyb4c").asBuilder()
.setNameservers(ImmutableSet.of(
ReferenceUnion.create(Ref.create(nameserver3)),
ReferenceUnion.create(Ref.create(nameserver4))))
.setNameservers(ImmutableSet.of(Ref.create(nameserver3), Ref.create(nameserver4)))
.build());
// Persist a domain in a different tld that should be ignored.
persistActiveDomain("should-be-ignored.example");

5
javatests/google/registry/tools/UniformRapidSuspensionCommandTest.java
View file

@ -24,7 +24,6 @@ import com.google.common.collect.ImmutableSet;
import com.beust.jcommander.ParameterException;
import com.googlecode.objectify.Ref;
import google.registry.model.domain.ReferenceUnion;
import google.registry.model.eppcommon.StatusValue;
import google.registry.model.host.HostResource;
import google.registry.model.registrar.Registrar;
@ -45,9 +44,9 @@ public class UniformRapidSuspensionCommandTest
}
private void persistDomainWithHosts(HostResource... hosts) {
ImmutableSet.Builder<ReferenceUnion<HostResource>> hostRefs = new ImmutableSet.Builder<>();
ImmutableSet.Builder<Ref<HostResource>> hostRefs = new ImmutableSet.Builder<>();
for (HostResource host : hosts) {
hostRefs.add(ReferenceUnion.create(Ref.create(host)));
hostRefs.add(Ref.create(host));
}
persistResource(newDomainResource("evil.tld").asBuilder()
.setNameservers(hostRefs.build())

9
javatests/google/registry/tools/server/GenerateZoneFilesActionTest.java
View file

@ -37,8 +37,9 @@ import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
import com.googlecode.objectify.Ref;
import google.registry.mapreduce.MapreduceRunner;
import google.registry.model.domain.ReferenceUnion;
import google.registry.model.domain.secdns.DelegationSignerData;
import google.registry.model.host.HostResource;
import google.registry.testing.FakeClock;
@ -73,10 +74,8 @@ public class GenerateZoneFilesActionTest extends MapreduceTestCase<GenerateZoneF
HostResource host2 =
persistResource(newHostResource("ns.bar.tld").asBuilder().addInetAddresses(ips).build());
ImmutableSet<ReferenceUnion<HostResource>> nameservers =
ImmutableSet.of(
ReferenceUnion.<HostResource>create(host1),
ReferenceUnion.<HostResource>create(host2));
ImmutableSet<Ref<HostResource>> nameservers =
ImmutableSet.of(Ref.create(host1), Ref.create(host2));
persistResource(newDomainResource("ns-and-ds.tld").asBuilder()
.addNameservers(nameservers)
.setDsData(ImmutableSet.of(DelegationSignerData.create(1, 2, 3, new byte[] {0, 1, 2})))

15
javatests/google/registry/whois/DomainWhoisResponseTest.java
View file

@ -32,7 +32,6 @@ import google.registry.model.contact.PostalInfo;
import google.registry.model.domain.DesignatedContact;
import google.registry.model.domain.DomainResource;
import google.registry.model.domain.GracePeriod;
import google.registry.model.domain.ReferenceUnion;
import google.registry.model.domain.rgp.GracePeriodStatus;
import google.registry.model.domain.secdns.DelegationSignerData;
import google.registry.model.eppcommon.StatusValue;
@ -227,17 +226,11 @@ public class DomainWhoisResponseTest {
StatusValue.CLIENT_RENEW_PROHIBITED,
StatusValue.CLIENT_TRANSFER_PROHIBITED,
StatusValue.SERVER_UPDATE_PROHIBITED))
.setRegistrant(ReferenceUnion.create(registrantResourceRef))
.setRegistrant(registrantResourceRef)
.setContacts(ImmutableSet.of(
DesignatedContact.create(
DesignatedContact.Type.ADMIN,
ReferenceUnion.create(adminResourceRef)),
DesignatedContact.create(
DesignatedContact.Type.TECH,
ReferenceUnion.create(techResourceRef))))
.setNameservers(ImmutableSet.of(
ReferenceUnion.create(hostResource1Ref),
ReferenceUnion.create(hostResource2Ref)))
DesignatedContact.create(DesignatedContact.Type.ADMIN, adminResourceRef),
DesignatedContact.create(DesignatedContact.Type.TECH, techResourceRef)))
.setNameservers(ImmutableSet.of(hostResource1Ref, hostResource2Ref))
.setDsData(ImmutableSet.of(new DelegationSignerData()))
.setGracePeriods(ImmutableSet.of(
GracePeriod.create(GracePeriodStatus.ADD, END_OF_TIME, "", null),