mirror of
https://github.com/google/nomulus.git
synced 2025-04-30 12:07:51 +02:00
5012893c1d
This change renames directories in preparation for the great package rename. The repository is now in a broken state because the code itself hasn't been updated. However this should ensure that git correctly preserves history for each file.
1266 lines
48 KiB
Java
1266 lines
48 KiB
Java
// Copyright 2016 The Domain Registry Authors. All Rights Reserved.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
package com.google.domain.registry.flows.domain;
|
|
|
|
import static com.google.common.io.BaseEncoding.base16;
|
|
import static com.google.common.truth.Truth.assertThat;
|
|
import static com.google.domain.registry.testing.DatastoreHelper.assertBillingEvents;
|
|
import static com.google.domain.registry.testing.DatastoreHelper.createTld;
|
|
import static com.google.domain.registry.testing.DatastoreHelper.deleteTld;
|
|
import static com.google.domain.registry.testing.DatastoreHelper.getHistoryEntries;
|
|
import static com.google.domain.registry.testing.DatastoreHelper.newContactResource;
|
|
import static com.google.domain.registry.testing.DatastoreHelper.newDomainApplication;
|
|
import static com.google.domain.registry.testing.DatastoreHelper.newDomainResource;
|
|
import static com.google.domain.registry.testing.DatastoreHelper.newHostResource;
|
|
import static com.google.domain.registry.testing.DatastoreHelper.persistActiveContact;
|
|
import static com.google.domain.registry.testing.DatastoreHelper.persistActiveDomain;
|
|
import static com.google.domain.registry.testing.DatastoreHelper.persistActiveDomainApplication;
|
|
import static com.google.domain.registry.testing.DatastoreHelper.persistActiveHost;
|
|
import static com.google.domain.registry.testing.DatastoreHelper.persistDeletedDomain;
|
|
import static com.google.domain.registry.testing.DatastoreHelper.persistReservedList;
|
|
import static com.google.domain.registry.testing.DatastoreHelper.persistResource;
|
|
import static com.google.domain.registry.testing.DomainResourceSubject.assertAboutDomains;
|
|
import static com.google.domain.registry.testing.TaskQueueHelper.assertDnsTasksEnqueued;
|
|
import static com.google.domain.registry.testing.TaskQueueHelper.assertNoDnsTasksEnqueued;
|
|
import static com.google.domain.registry.testing.TestDataHelper.loadFileWithSubstitutions;
|
|
import static com.google.domain.registry.util.DateTimeUtils.END_OF_TIME;
|
|
import static com.google.domain.registry.util.DateTimeUtils.START_OF_TIME;
|
|
import static org.joda.money.CurrencyUnit.EUR;
|
|
import static org.joda.money.CurrencyUnit.USD;
|
|
|
|
import com.google.common.base.Strings;
|
|
import com.google.common.collect.ImmutableMap;
|
|
import com.google.common.collect.ImmutableSet;
|
|
import com.google.common.collect.ImmutableSortedMap;
|
|
import com.google.domain.registry.flows.EppException.UnimplementedExtensionException;
|
|
import com.google.domain.registry.flows.FlowRunner.CommitMode;
|
|
import com.google.domain.registry.flows.FlowRunner.UserPrivileges;
|
|
import com.google.domain.registry.flows.LoggedInFlow.UndeclaredServiceExtensionException;
|
|
import com.google.domain.registry.flows.ResourceCreateFlow.ResourceAlreadyExistsException;
|
|
import com.google.domain.registry.flows.ResourceCreateOrMutateFlow.OnlyToolCanPassMetadataException;
|
|
import com.google.domain.registry.flows.ResourceFlow.BadCommandForRegistryPhaseException;
|
|
import com.google.domain.registry.flows.ResourceFlowTestCase;
|
|
import com.google.domain.registry.flows.SessionMetadata.SessionSource;
|
|
import com.google.domain.registry.flows.domain.BaseDomainCreateFlow.AcceptedTooLongAgoException;
|
|
import com.google.domain.registry.flows.domain.BaseDomainCreateFlow.ClaimsPeriodEndedException;
|
|
import com.google.domain.registry.flows.domain.BaseDomainCreateFlow.ExpiredClaimException;
|
|
import com.google.domain.registry.flows.domain.BaseDomainCreateFlow.InvalidTcnIdChecksumException;
|
|
import com.google.domain.registry.flows.domain.BaseDomainCreateFlow.InvalidTrademarkValidatorException;
|
|
import com.google.domain.registry.flows.domain.BaseDomainCreateFlow.MalformedTcnIdException;
|
|
import com.google.domain.registry.flows.domain.BaseDomainCreateFlow.MaxSigLifeNotSupportedException;
|
|
import com.google.domain.registry.flows.domain.BaseDomainCreateFlow.MissingClaimsNoticeException;
|
|
import com.google.domain.registry.flows.domain.BaseDomainCreateFlow.UnexpectedClaimsNoticeException;
|
|
import com.google.domain.registry.flows.domain.BaseDomainCreateFlow.UnsupportedMarkTypeException;
|
|
import com.google.domain.registry.flows.domain.DomainCreateFlow.DomainHasOpenApplicationsException;
|
|
import com.google.domain.registry.flows.domain.DomainCreateFlow.NoGeneralRegistrationsInCurrentPhaseException;
|
|
import com.google.domain.registry.flows.domain.DomainCreateFlow.SignedMarksNotAcceptedInCurrentPhaseException;
|
|
import com.google.domain.registry.flows.domain.DomainFlowUtils.BadDomainNameCharacterException;
|
|
import com.google.domain.registry.flows.domain.DomainFlowUtils.BadDomainNamePartsCountException;
|
|
import com.google.domain.registry.flows.domain.DomainFlowUtils.BadPeriodUnitException;
|
|
import com.google.domain.registry.flows.domain.DomainFlowUtils.CurrencyUnitMismatchException;
|
|
import com.google.domain.registry.flows.domain.DomainFlowUtils.CurrencyValueScaleException;
|
|
import com.google.domain.registry.flows.domain.DomainFlowUtils.DashesInThirdAndFourthException;
|
|
import com.google.domain.registry.flows.domain.DomainFlowUtils.DomainLabelTooLongException;
|
|
import com.google.domain.registry.flows.domain.DomainFlowUtils.DomainReservedException;
|
|
import com.google.domain.registry.flows.domain.DomainFlowUtils.DuplicateContactForRoleException;
|
|
import com.google.domain.registry.flows.domain.DomainFlowUtils.EmptyDomainNamePartException;
|
|
import com.google.domain.registry.flows.domain.DomainFlowUtils.FeesMismatchException;
|
|
import com.google.domain.registry.flows.domain.DomainFlowUtils.FeesRequiredForPremiumNameException;
|
|
import com.google.domain.registry.flows.domain.DomainFlowUtils.InvalidIdnDomainLabelException;
|
|
import com.google.domain.registry.flows.domain.DomainFlowUtils.InvalidPunycodeException;
|
|
import com.google.domain.registry.flows.domain.DomainFlowUtils.LeadingDashException;
|
|
import com.google.domain.registry.flows.domain.DomainFlowUtils.LinkedResourceDoesNotExistException;
|
|
import com.google.domain.registry.flows.domain.DomainFlowUtils.LinkedResourceInPendingDeleteProhibitsOperationException;
|
|
import com.google.domain.registry.flows.domain.DomainFlowUtils.MissingAdminContactException;
|
|
import com.google.domain.registry.flows.domain.DomainFlowUtils.MissingContactTypeException;
|
|
import com.google.domain.registry.flows.domain.DomainFlowUtils.MissingRegistrantException;
|
|
import com.google.domain.registry.flows.domain.DomainFlowUtils.MissingTechnicalContactException;
|
|
import com.google.domain.registry.flows.domain.DomainFlowUtils.NameserverNotAllowedException;
|
|
import com.google.domain.registry.flows.domain.DomainFlowUtils.NotAuthorizedForTldException;
|
|
import com.google.domain.registry.flows.domain.DomainFlowUtils.PremiumNameBlockedException;
|
|
import com.google.domain.registry.flows.domain.DomainFlowUtils.RegistrantNotAllowedException;
|
|
import com.google.domain.registry.flows.domain.DomainFlowUtils.TldDoesNotExistException;
|
|
import com.google.domain.registry.flows.domain.DomainFlowUtils.TooManyDsRecordsException;
|
|
import com.google.domain.registry.flows.domain.DomainFlowUtils.TooManyNameserversException;
|
|
import com.google.domain.registry.flows.domain.DomainFlowUtils.TrailingDashException;
|
|
import com.google.domain.registry.flows.domain.DomainFlowUtils.UnsupportedFeeAttributeException;
|
|
import com.google.domain.registry.model.billing.BillingEvent;
|
|
import com.google.domain.registry.model.billing.BillingEvent.Flag;
|
|
import com.google.domain.registry.model.billing.BillingEvent.Reason;
|
|
import com.google.domain.registry.model.domain.DomainResource;
|
|
import com.google.domain.registry.model.domain.GracePeriod;
|
|
import com.google.domain.registry.model.domain.launch.ApplicationStatus;
|
|
import com.google.domain.registry.model.domain.launch.LaunchNotice;
|
|
import com.google.domain.registry.model.domain.rgp.GracePeriodStatus;
|
|
import com.google.domain.registry.model.domain.secdns.DelegationSignerData;
|
|
import com.google.domain.registry.model.eppcommon.ProtocolDefinition.ServiceExtension;
|
|
import com.google.domain.registry.model.eppcommon.StatusValue;
|
|
import com.google.domain.registry.model.registrar.Registrar;
|
|
import com.google.domain.registry.model.registry.Registry;
|
|
import com.google.domain.registry.model.registry.Registry.TldState;
|
|
import com.google.domain.registry.model.reporting.HistoryEntry;
|
|
import com.google.domain.registry.testing.DatastoreHelper;
|
|
|
|
import org.joda.money.CurrencyUnit;
|
|
import org.joda.money.Money;
|
|
import org.joda.time.DateTime;
|
|
import org.joda.time.Duration;
|
|
import org.junit.Before;
|
|
import org.junit.Test;
|
|
|
|
/** Unit tests for {@link DomainCreateFlow}. */
|
|
public class DomainCreateFlowTest extends ResourceFlowTestCase<DomainCreateFlow, DomainResource> {
|
|
|
|
private static final String CLAIMS_KEY = "2013041500/2/6/9/rJ1NrDO92vDsAzf7EQzgjX4R0000000001";
|
|
|
|
public DomainCreateFlowTest() {
|
|
setEppInput("domain_create.xml");
|
|
clock.setTo(DateTime.parse("1999-04-03T22:00:00.0Z").minus(1));
|
|
}
|
|
|
|
@Before
|
|
public void initCreateTest() throws Exception {
|
|
createTld("tld");
|
|
persistResource(Registry.get("tld").asBuilder()
|
|
.setReservedLists(persistReservedList(
|
|
"tld-reserved",
|
|
"reserved,FULLY_BLOCKED",
|
|
"anchor,RESERVED_FOR_ANCHOR_TENANT,2fooBAR"))
|
|
.build());
|
|
persistClaimsList(ImmutableMap.of("example-one", CLAIMS_KEY));
|
|
}
|
|
|
|
/**
|
|
* Create host and contact entries for testing.
|
|
* @param hostTld the TLD of the host (which might be an external TLD)
|
|
*/
|
|
private void persistContactsAndHosts(String hostTld) {
|
|
for (int i = 1; i <= 14; ++i) {
|
|
persistActiveHost(String.format("ns%d.example.%s", i, hostTld));
|
|
}
|
|
persistActiveContact("jd1234");
|
|
persistActiveContact("sh8013");
|
|
clock.advanceOneMilli();
|
|
}
|
|
|
|
private void persistContactsAndHosts() {
|
|
persistContactsAndHosts("net"); // domain_create.xml uses hosts on "net".
|
|
}
|
|
|
|
private void assertSuccessfulCreate(String domainTld, boolean isAnchorTenant) throws Exception {
|
|
DomainResource domain = reloadResourceByUniqueId();
|
|
DateTime billingTime = isAnchorTenant
|
|
? clock.nowUtc().plus(Registry.get(domainTld).getAnchorTenantAddGracePeriodLength())
|
|
: clock.nowUtc().plus(Registry.get(domainTld).getAddGracePeriodLength());
|
|
ImmutableSet<BillingEvent.Flag> billingFlags = isAnchorTenant
|
|
? ImmutableSet.of(BillingEvent.Flag.ANCHOR_TENANT)
|
|
: null;
|
|
HistoryEntry historyEntry = getHistoryEntries(domain).get(0);
|
|
assertAboutDomains().that(domain)
|
|
.hasRegistrationExpirationTime(domain.getAutorenewBillingEvent().get().getEventTime()).and()
|
|
.hasOnlyOneHistoryEntryWhich()
|
|
.hasType(HistoryEntry.Type.DOMAIN_CREATE).and()
|
|
.hasPeriodYears(2);
|
|
// There should be a bill for the create and a recurring autorenew event.
|
|
BillingEvent.OneTime createBillingEvent = new BillingEvent.OneTime.Builder()
|
|
.setReason(Reason.CREATE)
|
|
.setTargetId(getUniqueIdFromCommand())
|
|
.setClientId("TheRegistrar")
|
|
.setCost(Registry.get(domainTld).isPremiumName(getUniqueIdFromCommand())
|
|
? Money.of(USD, 200)
|
|
: Money.of(USD, 26))
|
|
.setPeriodYears(2)
|
|
.setEventTime(clock.nowUtc())
|
|
.setBillingTime(billingTime)
|
|
.setFlags(billingFlags)
|
|
.setParent(historyEntry)
|
|
.build();
|
|
assertBillingEvents(
|
|
createBillingEvent,
|
|
new BillingEvent.Recurring.Builder()
|
|
.setReason(Reason.RENEW)
|
|
.setFlags(ImmutableSet.of(Flag.AUTO_RENEW))
|
|
.setTargetId(getUniqueIdFromCommand())
|
|
.setClientId("TheRegistrar")
|
|
.setEventTime(domain.getRegistrationExpirationTime())
|
|
.setRecurrenceEndTime(END_OF_TIME)
|
|
.setParent(historyEntry)
|
|
.build());
|
|
assertGracePeriods(
|
|
domain.getGracePeriods(),
|
|
ImmutableMap.of(
|
|
GracePeriod.create(
|
|
GracePeriodStatus.ADD,
|
|
billingTime,
|
|
"TheRegistrar",
|
|
null),
|
|
createBillingEvent));
|
|
assertDnsTasksEnqueued(getUniqueIdFromCommand());
|
|
assertEppResourceIndexEntityFor(domain);
|
|
}
|
|
|
|
private void assertNoLordn() throws Exception {
|
|
// TODO(b/26161326): Assert tasks NOT enqueued.
|
|
assertAboutDomains().that(reloadResourceByUniqueId())
|
|
.hasSmdId(null).and()
|
|
.hasLaunchNotice(null);
|
|
}
|
|
|
|
private void assertSunriseLordn() throws Exception {
|
|
// TODO(b/26161326): Assert tasks enqueued.
|
|
assertAboutDomains().that(reloadResourceByUniqueId())
|
|
.hasSmdId("0000001761376042759136-65535").and()
|
|
.hasLaunchNotice(null);
|
|
}
|
|
|
|
private void assertClaimsLordn() throws Exception {
|
|
// TODO(b/26161326): Assert tasks enqueued.
|
|
assertAboutDomains().that(reloadResourceByUniqueId())
|
|
.hasSmdId(null).and()
|
|
.hasLaunchNotice(LaunchNotice.create(
|
|
"370d0b7c9223372036854775807",
|
|
"tmch",
|
|
DateTime.parse("2010-08-16T09:00:00.0Z"),
|
|
DateTime.parse("2009-08-16T09:00:00.0Z")));
|
|
}
|
|
|
|
private void doSuccessfulTest(
|
|
String domainTld,
|
|
String responseXmlFile,
|
|
UserPrivileges userPrivileges) throws Exception {
|
|
assertTransactionalFlow(true);
|
|
runFlowAssertResponse(CommitMode.LIVE, userPrivileges, readFile(responseXmlFile));
|
|
assertSuccessfulCreate(domainTld, false);
|
|
assertNoLordn();
|
|
}
|
|
|
|
private void doSuccessfulTest(String domainTld, String responseXmlFile) throws Exception {
|
|
doSuccessfulTest(domainTld, responseXmlFile, UserPrivileges.NORMAL);
|
|
}
|
|
|
|
private void doSuccessfulTest(String domainTld) throws Exception {
|
|
doSuccessfulTest(domainTld, "domain_create_response.xml");
|
|
}
|
|
|
|
private void doSuccessfulTest() throws Exception {
|
|
doSuccessfulTest("tld");
|
|
}
|
|
|
|
@Test
|
|
public void testDryRun() throws Exception {
|
|
persistContactsAndHosts();
|
|
dryRunFlowAssertResponse(readFile("domain_create_response.xml"));
|
|
}
|
|
|
|
@Test
|
|
public void testSuccess_neverExisted() throws Exception {
|
|
persistContactsAndHosts();
|
|
doSuccessfulTest();
|
|
}
|
|
|
|
@Test
|
|
public void testSuccess_multipartTld() throws Exception {
|
|
createTld("foo.tld");
|
|
setEppInput("domain_create_with_tld.xml", ImmutableMap.of("TLD", "foo.tld"));
|
|
persistContactsAndHosts("foo.tld");
|
|
assertTransactionalFlow(true);
|
|
String expectedResponseXml = loadFileWithSubstitutions(
|
|
DomainCreateFlowTest.class,
|
|
"domain_create_response_wildcard.xml",
|
|
ImmutableMap.of("DOMAIN", "example.foo.tld"));
|
|
runFlowAssertResponse(CommitMode.LIVE, UserPrivileges.NORMAL, expectedResponseXml);
|
|
assertSuccessfulCreate("foo.tld", false);
|
|
assertNoLordn();
|
|
}
|
|
|
|
@Test
|
|
public void testSuccess_anchorTenantViaExtension() throws Exception {
|
|
sessionMetadata.setSessionSource(SessionSource.TOOL);
|
|
setEppInput("domain_create_anchor_tenant.xml");
|
|
persistContactsAndHosts();
|
|
runFlowAssertResponse(readFile("domain_create_response.xml"));
|
|
assertSuccessfulCreate("tld", true);
|
|
assertNoLordn();
|
|
}
|
|
|
|
@Test
|
|
public void testSuccess_fee() throws Exception {
|
|
setEppInput("domain_create_fee.xml");
|
|
persistContactsAndHosts();
|
|
doSuccessfulTest("tld", "domain_create_response_fee.xml");
|
|
}
|
|
|
|
@Test
|
|
public void testSuccess_fee_withDefaultAttributes() throws Exception {
|
|
setEppInput("domain_create_fee_defaults.xml");
|
|
persistContactsAndHosts();
|
|
doSuccessfulTest("tld", "domain_create_response_fee.xml");
|
|
}
|
|
|
|
@Test
|
|
public void testFailure_refundableFee() throws Exception {
|
|
thrown.expect(UnsupportedFeeAttributeException.class);
|
|
setEppInput("domain_create_fee_refundable.xml");
|
|
persistContactsAndHosts();
|
|
runFlow();
|
|
}
|
|
|
|
@Test
|
|
public void testFailure_gracePeriodFee() throws Exception {
|
|
thrown.expect(UnsupportedFeeAttributeException.class);
|
|
setEppInput("domain_create_fee_grace_period.xml");
|
|
persistContactsAndHosts();
|
|
runFlow();
|
|
}
|
|
|
|
@Test
|
|
public void testFailure_appliedFee() throws Exception {
|
|
thrown.expect(UnsupportedFeeAttributeException.class);
|
|
setEppInput("domain_create_fee_applied.xml");
|
|
persistContactsAndHosts();
|
|
runFlow();
|
|
}
|
|
|
|
@Test
|
|
public void testSuccess_metadata() throws Exception {
|
|
sessionMetadata.setSessionSource(SessionSource.TOOL);
|
|
setEppInput("domain_create_metadata.xml");
|
|
persistContactsAndHosts();
|
|
doSuccessfulTest();
|
|
assertAboutDomains().that(reloadResourceByUniqueId())
|
|
.hasOnlyOneHistoryEntryWhich()
|
|
.hasType(HistoryEntry.Type.DOMAIN_CREATE).and()
|
|
.hasMetadataReason("domain-create-test").and()
|
|
.hasMetadataRequestedByRegistrar(false);
|
|
}
|
|
|
|
@Test
|
|
public void testFailure_metadataNotFromTool() throws Exception {
|
|
thrown.expect(OnlyToolCanPassMetadataException.class);
|
|
setEppInput("domain_create_metadata.xml");
|
|
persistContactsAndHosts();
|
|
runFlow();
|
|
}
|
|
|
|
@Test
|
|
public void testSuccess_premium() throws Exception {
|
|
createTld("example");
|
|
persistResource(Registry.get("example").asBuilder().setPremiumPriceAckRequired(false).build());
|
|
setEppInput("domain_create_premium.xml");
|
|
persistContactsAndHosts("net");
|
|
doSuccessfulTest("example", "domain_create_response_premium.xml");
|
|
}
|
|
|
|
/**
|
|
* Test fix for a bug where we were looking at the length of the unicode string but indexing
|
|
* into the punycode string. In rare cases (3 and 4 letter labels) this would cause us to think
|
|
* there was a trailing dash in the domain name and fail to create it.
|
|
*/
|
|
@Test
|
|
public void testSuccess_unicodeLengthBug() throws Exception {
|
|
createTld("xn--q9jyb4c");
|
|
persistContactsAndHosts("net");
|
|
eppLoader.replaceAll("example.tld", "osx.xn--q9jyb4c");
|
|
runFlow();
|
|
}
|
|
|
|
@Test
|
|
public void testSuccess_nonDefaultAddGracePeriod() throws Exception {
|
|
persistResource(Registry.get("tld").asBuilder()
|
|
.setAddGracePeriodLength(Duration.standardMinutes(6))
|
|
.build());
|
|
persistContactsAndHosts();
|
|
doSuccessfulTest();
|
|
}
|
|
|
|
@Test
|
|
public void testSuccess_existedButWasDeleted() throws Exception {
|
|
persistContactsAndHosts();
|
|
persistDeletedDomain(getUniqueIdFromCommand(), clock.nowUtc());
|
|
clock.advanceOneMilli();
|
|
doSuccessfulTest();
|
|
}
|
|
|
|
@Test
|
|
public void testSuccess_maxNumberOfNameservers() throws Exception {
|
|
setEppInput("domain_create_13_nameservers.xml");
|
|
persistContactsAndHosts();
|
|
doSuccessfulTest();
|
|
}
|
|
|
|
@Test
|
|
public void testSuccess_secDns() throws Exception {
|
|
setEppInput("domain_create_dsdata_no_maxsiglife.xml");
|
|
persistContactsAndHosts("tld"); // For some reason this sample uses "tld".
|
|
doSuccessfulTest("tld");
|
|
assertAboutDomains().that(reloadResourceByUniqueId()).hasExactlyDsData(
|
|
DelegationSignerData.create(12345, 3, 1, base16().decode("49FD46E6C4B45C55D4AC")));
|
|
}
|
|
|
|
@Test
|
|
public void testSuccess_secDnsMaxRecords() throws Exception {
|
|
setEppInput("domain_create_dsdata_8_records.xml");
|
|
persistContactsAndHosts("tld"); // For some reason this sample uses "tld".
|
|
doSuccessfulTest("tld");
|
|
assertAboutDomains().that(reloadResourceByUniqueId()).hasNumDsData(8);
|
|
}
|
|
|
|
@Test
|
|
public void testSuccess_idn() throws Exception {
|
|
createTld("xn--q9jyb4c");
|
|
setEppInput("domain_create_idn_minna.xml");
|
|
persistContactsAndHosts("net");
|
|
runFlowAssertResponse(readFile("domain_create_response_idn_minna.xml"));
|
|
assertSuccessfulCreate("xn--q9jyb4c", false);
|
|
assertDnsTasksEnqueued("xn--abc-873b2e7eb1k8a4lpjvv.xn--q9jyb4c");
|
|
}
|
|
|
|
@Test
|
|
public void testSuccess_noNameserversOrDsData() throws Exception {
|
|
setEppInput("domain_create_no_hosts_or_dsdata.xml");
|
|
persistContactsAndHosts();
|
|
runFlowAssertResponse(readFile("domain_create_response.xml"));
|
|
assertNoDnsTasksEnqueued();
|
|
}
|
|
|
|
@Test
|
|
public void testSuccess_periodNotSpecified() throws Exception {
|
|
setEppInput("domain_create_missing_period.xml");
|
|
persistContactsAndHosts();
|
|
runFlowAssertResponse(readFile("domain_create_response.xml"),
|
|
"epp.response.resData.creData.exDate"); // Ignore expiration date; we verify it below
|
|
assertAboutDomains().that(reloadResourceByUniqueId())
|
|
.hasRegistrationExpirationTime(clock.nowUtc().plusYears(1));
|
|
assertDnsTasksEnqueued("example.tld");
|
|
}
|
|
|
|
@Test
|
|
public void testFailure_periodInMonths() throws Exception {
|
|
thrown.expect(BadPeriodUnitException.class);
|
|
setEppInput("domain_create_months.xml");
|
|
persistContactsAndHosts();
|
|
runFlow();
|
|
}
|
|
|
|
@Test
|
|
public void testSuccess_claimsNotice() throws Exception {
|
|
clock.setTo(DateTime.parse("2009-08-16T09:00:00.0Z"));
|
|
setEppInput("domain_create_claim_notice.xml");
|
|
persistContactsAndHosts();
|
|
runFlowAssertResponse(readFile("domain_create_response_claims.xml"));
|
|
assertSuccessfulCreate("tld", false);
|
|
assertDnsTasksEnqueued("example-one.tld");
|
|
assertClaimsLordn();
|
|
}
|
|
|
|
@Test
|
|
public void testSuccess_noClaimsNotice_forClaimsListName_afterClaimsPeriodEnd() throws Exception {
|
|
persistClaimsList(ImmutableMap.of("example", CLAIMS_KEY));
|
|
setEppInput("domain_create.xml");
|
|
persistContactsAndHosts();
|
|
persistResource(Registry.get("tld").asBuilder()
|
|
.setClaimsPeriodEnd(clock.nowUtc())
|
|
.build());
|
|
runFlowAssertResponse(readFile("domain_create_response.xml"));
|
|
assertSuccessfulCreate("tld", false);
|
|
assertDnsTasksEnqueued("example.tld");
|
|
}
|
|
|
|
@Test
|
|
public void testFailure_missingClaimsNotice() throws Exception {
|
|
thrown.expect(MissingClaimsNoticeException.class);
|
|
persistClaimsList(ImmutableMap.of("example", CLAIMS_KEY));
|
|
setEppInput("domain_create.xml");
|
|
persistContactsAndHosts();
|
|
runFlow();
|
|
}
|
|
|
|
@Test
|
|
public void testFailure_claimsNoticeProvided_nameNotOnClaimsList() throws Exception {
|
|
thrown.expect(UnexpectedClaimsNoticeException.class);
|
|
setEppInput("domain_create_claim_notice.xml");
|
|
persistClaimsList(ImmutableMap.<String, String>of());
|
|
persistContactsAndHosts();
|
|
runFlow();
|
|
}
|
|
|
|
@Test
|
|
public void testFailure_claimsNoticeProvided_claimsPeriodEnded() throws Exception {
|
|
thrown.expect(ClaimsPeriodEndedException.class);
|
|
setEppInput("domain_create_claim_notice.xml");
|
|
persistClaimsList(ImmutableMap.of("example-one", CLAIMS_KEY));
|
|
persistContactsAndHosts();
|
|
persistResource(Registry.get("tld").asBuilder()
|
|
.setClaimsPeriodEnd(clock.nowUtc())
|
|
.build());
|
|
runFlow();
|
|
}
|
|
|
|
@Test
|
|
public void testFailure_tooManyNameservers() throws Exception {
|
|
thrown.expect(TooManyNameserversException.class);
|
|
setEppInput("domain_create_14_nameservers.xml");
|
|
persistContactsAndHosts();
|
|
runFlow();
|
|
}
|
|
|
|
@Test
|
|
public void testFailure_secDnsMaxSigLife() throws Exception {
|
|
thrown.expect(MaxSigLifeNotSupportedException.class);
|
|
setEppInput("domain_create_dsdata.xml");
|
|
persistContactsAndHosts();
|
|
runFlow();
|
|
}
|
|
|
|
@Test
|
|
public void testFailure_secDnsTooManyDsRecords() throws Exception {
|
|
thrown.expect(TooManyDsRecordsException.class);
|
|
setEppInput("domain_create_dsdata_9_records.xml");
|
|
persistContactsAndHosts();
|
|
runFlow();
|
|
}
|
|
|
|
@Test
|
|
public void testFailure_wrongExtension() throws Exception {
|
|
thrown.expect(UnimplementedExtensionException.class);
|
|
setEppInput("domain_create_wrong_extension.xml");
|
|
persistContactsAndHosts();
|
|
runFlow();
|
|
}
|
|
|
|
@Test
|
|
public void testFailure_wrongFeeAmount() throws Exception {
|
|
thrown.expect(FeesMismatchException.class);
|
|
setEppInput("domain_create_fee.xml");
|
|
persistResource(Registry.get("tld").asBuilder().setCreateBillingCost(Money.of(USD, 20)).build());
|
|
persistContactsAndHosts();
|
|
runFlow();
|
|
}
|
|
|
|
@Test
|
|
public void testFailure_wrongCurrency() throws Exception {
|
|
thrown.expect(CurrencyUnitMismatchException.class);
|
|
setEppInput("domain_create_fee.xml");
|
|
persistResource(Registry.get("tld").asBuilder()
|
|
.setCurrency(CurrencyUnit.EUR)
|
|
.setCreateBillingCost(Money.of(EUR, 13))
|
|
.setRestoreBillingCost(Money.of(EUR, 11))
|
|
.setRenewBillingCostTransitions(ImmutableSortedMap.of(START_OF_TIME, Money.of(EUR, 7)))
|
|
.setServerStatusChangeBillingCost(Money.of(EUR, 19))
|
|
.build());
|
|
persistContactsAndHosts();
|
|
runFlow();
|
|
}
|
|
|
|
@Test
|
|
public void testFailure_alreadyExists() throws Exception {
|
|
// This fails fast and throws DomainAlreadyExistsException from init() as a special case.
|
|
thrown.expect(
|
|
ResourceAlreadyExistsException.class,
|
|
String.format("Object with given ID (%s) already exists", getUniqueIdFromCommand()));
|
|
persistContactsAndHosts();
|
|
persistActiveDomain(getUniqueIdFromCommand());
|
|
try {
|
|
runFlow();
|
|
} catch (ResourceAlreadyExistsException e) {
|
|
assertThat(e.isFailfast()).isTrue();
|
|
throw e;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* There is special logic that disallows a failfast for domains in add grace period and sunrush
|
|
* add grace period, so make sure that they fail anyways in the actual flow.
|
|
*/
|
|
private void doNonFailFastAlreadyExistsTest(GracePeriodStatus gracePeriodStatus)
|
|
throws Exception {
|
|
// This doesn't fail fast, so it throws the regular ResourceAlreadyExistsException from run().
|
|
thrown.expect(
|
|
ResourceAlreadyExistsException.class,
|
|
String.format("Object with given ID (%s) already exists", getUniqueIdFromCommand()));
|
|
persistContactsAndHosts();
|
|
persistResource(newDomainResource(getUniqueIdFromCommand()).asBuilder()
|
|
.addGracePeriod(GracePeriod.create(gracePeriodStatus, END_OF_TIME, "", null))
|
|
.build());
|
|
try {
|
|
runFlow();
|
|
} catch (ResourceAlreadyExistsException e) {
|
|
assertThat(e.isFailfast()).isFalse();
|
|
throw e;
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public void testFailure_alreadyExists_addGracePeriod() throws Exception {
|
|
doNonFailFastAlreadyExistsTest(GracePeriodStatus.ADD);
|
|
}
|
|
|
|
@Test
|
|
public void testFailure_alreadyExists_sunrushAddGracePeriod() throws Exception {
|
|
doNonFailFastAlreadyExistsTest(GracePeriodStatus.SUNRUSH_ADD);
|
|
}
|
|
|
|
@Test
|
|
public void testFailure_reserved() throws Exception {
|
|
thrown.expect(DomainReservedException.class);
|
|
setEppInput("domain_create_reserved.xml");
|
|
persistContactsAndHosts();
|
|
runFlow();
|
|
}
|
|
|
|
@Test
|
|
public void testFailure_anchorTenantViaAuthCode_wrongAuthCode() throws Exception {
|
|
thrown.expect(DomainReservedException.class);
|
|
setEppInput("domain_create_anchor_wrong_authcode.xml");
|
|
persistContactsAndHosts();
|
|
runFlow();
|
|
}
|
|
|
|
@Test
|
|
public void testSuccess_anchorTenantViaAuthCode() throws Exception {
|
|
setEppInput("domain_create_anchor_authcode.xml");
|
|
persistContactsAndHosts();
|
|
runFlow();
|
|
assertSuccessfulCreate("tld", true);
|
|
}
|
|
|
|
@Test
|
|
public void testSuccess_anchorTenantViaAuthCode_withClaims() throws Exception {
|
|
persistResource(Registry.get("tld").asBuilder()
|
|
.setReservedLists(persistReservedList(
|
|
"anchor-with-claims",
|
|
"example-one,RESERVED_FOR_ANCHOR_TENANT,2fooBAR"))
|
|
.build());
|
|
setEppInput("domain_create_claim_notice.xml");
|
|
clock.setTo(DateTime.parse("2009-08-16T09:00:00.0Z"));
|
|
persistContactsAndHosts();
|
|
runFlowAssertResponse(readFile("domain_create_response_claims.xml"));
|
|
assertSuccessfulCreate("tld", true);
|
|
assertDnsTasksEnqueued("example-one.tld");
|
|
assertClaimsLordn();
|
|
}
|
|
|
|
@Test
|
|
public void testSuccess_superuserReserved() throws Exception {
|
|
setEppInput("domain_create_reserved.xml");
|
|
persistContactsAndHosts();
|
|
runFlowAssertResponse(
|
|
CommitMode.LIVE,
|
|
UserPrivileges.SUPERUSER,
|
|
readFile("domain_create_reserved_response.xml"));
|
|
assertSuccessfulCreate("tld", false);
|
|
}
|
|
|
|
@Test
|
|
public void testFailure_missingHost() throws Exception {
|
|
thrown.expect(
|
|
LinkedResourceDoesNotExistException.class,
|
|
"(ns2.example.net)");
|
|
persistActiveHost("ns1.example.net");
|
|
persistActiveContact("jd1234");
|
|
persistActiveContact("sh8013");
|
|
runFlow();
|
|
}
|
|
|
|
@Test
|
|
public void testFailure_pendingDeleteHost() throws Exception {
|
|
thrown.expect(
|
|
LinkedResourceInPendingDeleteProhibitsOperationException.class,
|
|
"ns2.example.net");
|
|
persistActiveHost("ns1.example.net");
|
|
persistActiveContact("jd1234");
|
|
persistActiveContact("sh8013");
|
|
persistResource(newHostResource("ns2.example.net").asBuilder()
|
|
.addStatusValue(StatusValue.PENDING_DELETE)
|
|
.build());
|
|
clock.advanceOneMilli();
|
|
runFlow();
|
|
}
|
|
|
|
@Test
|
|
public void testFailure_openApplication() throws Exception {
|
|
thrown.expect(DomainHasOpenApplicationsException.class);
|
|
persistContactsAndHosts();
|
|
persistActiveDomainApplication(getUniqueIdFromCommand());
|
|
clock.advanceOneMilli();
|
|
runFlow();
|
|
}
|
|
|
|
@Test
|
|
public void testSuccess_superuserOpenApplication() throws Exception {
|
|
persistContactsAndHosts();
|
|
persistActiveDomainApplication(getUniqueIdFromCommand());
|
|
doSuccessfulTest("tld", "domain_create_response.xml", UserPrivileges.SUPERUSER);
|
|
}
|
|
|
|
@Test
|
|
public void testSuccess_rejectedApplication() throws Exception {
|
|
persistContactsAndHosts();
|
|
persistResource(newDomainApplication(getUniqueIdFromCommand()).asBuilder()
|
|
.setApplicationStatus(ApplicationStatus.REJECTED)
|
|
.build());
|
|
clock.advanceOneMilli();
|
|
doSuccessfulTest();
|
|
}
|
|
|
|
@Test
|
|
public void testFailure_missingContact() throws Exception {
|
|
thrown.expect(
|
|
LinkedResourceDoesNotExistException.class,
|
|
"(sh8013)");
|
|
persistActiveHost("ns1.example.net");
|
|
persistActiveHost("ns2.example.net");
|
|
persistActiveContact("jd1234");
|
|
runFlow();
|
|
}
|
|
|
|
@Test
|
|
public void testFailure_pendingDeleteContact() throws Exception {
|
|
thrown.expect(
|
|
LinkedResourceInPendingDeleteProhibitsOperationException.class,
|
|
"jd1234");
|
|
persistActiveHost("ns1.example.net");
|
|
persistActiveHost("ns2.example.net");
|
|
persistActiveContact("sh8013");
|
|
persistResource(newContactResource("jd1234").asBuilder()
|
|
.addStatusValue(StatusValue.PENDING_DELETE)
|
|
.build());
|
|
clock.advanceOneMilli();
|
|
runFlow();
|
|
}
|
|
|
|
@Test
|
|
public void testFailure_wrongTld() throws Exception {
|
|
thrown.expect(TldDoesNotExistException.class);
|
|
persistContactsAndHosts("net");
|
|
deleteTld("tld");
|
|
runFlow();
|
|
}
|
|
|
|
@Test
|
|
public void testFailure_predelegation() throws Exception {
|
|
thrown.expect(BadCommandForRegistryPhaseException.class);
|
|
createTld("tld", TldState.PREDELEGATION);
|
|
persistContactsAndHosts();
|
|
runFlow();
|
|
}
|
|
|
|
@Test
|
|
public void testFailure_sunrise() throws Exception {
|
|
thrown.expect(NoGeneralRegistrationsInCurrentPhaseException.class);
|
|
createTld("tld", TldState.SUNRISE);
|
|
persistContactsAndHosts();
|
|
runFlow();
|
|
}
|
|
|
|
@Test
|
|
public void testFailure_sunrush() throws Exception {
|
|
thrown.expect(NoGeneralRegistrationsInCurrentPhaseException.class);
|
|
createTld("tld", TldState.SUNRUSH);
|
|
persistContactsAndHosts();
|
|
runFlow();
|
|
}
|
|
|
|
@Test
|
|
public void testFailure_landrush() throws Exception {
|
|
thrown.expect(NoGeneralRegistrationsInCurrentPhaseException.class);
|
|
createTld("tld", TldState.LANDRUSH);
|
|
persistContactsAndHosts();
|
|
runFlow();
|
|
}
|
|
|
|
@Test
|
|
public void testFailure_quietPeriod() throws Exception {
|
|
thrown.expect(NoGeneralRegistrationsInCurrentPhaseException.class);
|
|
createTld("tld", TldState.QUIET_PERIOD);
|
|
persistContactsAndHosts();
|
|
runFlow();
|
|
}
|
|
|
|
@Test
|
|
public void testSuccess_superuserPredelegation() throws Exception {
|
|
createTld("tld", TldState.PREDELEGATION);
|
|
persistContactsAndHosts();
|
|
doSuccessfulTest("tld", "domain_create_response.xml", UserPrivileges.SUPERUSER);
|
|
}
|
|
|
|
@Test
|
|
public void testSuccess_superuserSunrush() throws Exception {
|
|
createTld("tld", TldState.SUNRUSH);
|
|
persistContactsAndHosts();
|
|
doSuccessfulTest("tld", "domain_create_response.xml", UserPrivileges.SUPERUSER);
|
|
}
|
|
|
|
@Test
|
|
public void testSuccess_superuserQuietPeriod() throws Exception {
|
|
createTld("tld", TldState.QUIET_PERIOD);
|
|
persistContactsAndHosts();
|
|
doSuccessfulTest("tld", "domain_create_response.xml", UserPrivileges.SUPERUSER);
|
|
}
|
|
|
|
@Test
|
|
public void testSuccess_superuserOverridesPremiumNameBlock() throws Exception {
|
|
createTld("example");
|
|
persistResource(Registry.get("example").asBuilder().setPremiumPriceAckRequired(false).build());
|
|
setEppInput("domain_create_premium.xml");
|
|
persistContactsAndHosts("net");
|
|
// Modify the Registrar to block premium names.
|
|
persistResource(Registrar.loadByClientId("TheRegistrar").asBuilder()
|
|
.setBlockPremiumNames(true)
|
|
.build());
|
|
runFlowAssertResponse(
|
|
CommitMode.LIVE,
|
|
UserPrivileges.SUPERUSER,
|
|
readFile("domain_create_response_premium.xml"));
|
|
assertSuccessfulCreate("example", false);
|
|
}
|
|
|
|
@Test
|
|
public void testFailure_duplicateContact() throws Exception {
|
|
thrown.expect(DuplicateContactForRoleException.class);
|
|
setEppInput("domain_create_duplicate_contact.xml");
|
|
persistContactsAndHosts();
|
|
runFlow();
|
|
}
|
|
|
|
@Test
|
|
public void testFailure_missingContactType() throws Exception {
|
|
// We need to test for missing type, but not for invalid - the schema enforces that for us.
|
|
thrown.expect(MissingContactTypeException.class);
|
|
setEppInput("domain_create_missing_contact_type.xml");
|
|
persistContactsAndHosts();
|
|
runFlow();
|
|
}
|
|
|
|
@Test
|
|
public void testFailure_missingRegistrant() throws Exception {
|
|
thrown.expect(MissingRegistrantException.class);
|
|
setEppInput("domain_create_missing_registrant.xml");
|
|
persistContactsAndHosts();
|
|
runFlow();
|
|
}
|
|
|
|
@Test
|
|
public void testFailure_missingAdmin() throws Exception {
|
|
thrown.expect(MissingAdminContactException.class);
|
|
setEppInput("domain_create_missing_admin.xml");
|
|
persistContactsAndHosts();
|
|
runFlow();
|
|
}
|
|
|
|
@Test
|
|
public void testFailure_missingTech() throws Exception {
|
|
thrown.expect(MissingTechnicalContactException.class);
|
|
setEppInput("domain_create_missing_tech.xml");
|
|
persistContactsAndHosts();
|
|
runFlow();
|
|
}
|
|
|
|
@Test
|
|
public void testFailure_badIdn() throws Exception {
|
|
thrown.expect(InvalidIdnDomainLabelException.class);
|
|
createTld("xn--q9jyb4c");
|
|
setEppInput("domain_create_bad_idn_minna.xml");
|
|
persistContactsAndHosts("net");
|
|
runFlow();
|
|
}
|
|
|
|
@Test
|
|
public void testFailure_badValidatorId() throws Exception {
|
|
thrown.expect(InvalidTrademarkValidatorException.class);
|
|
setEppInput("domain_create_bad_validator_id.xml");
|
|
persistClaimsList(ImmutableMap.of("exampleone", CLAIMS_KEY));
|
|
persistContactsAndHosts();
|
|
runFlow();
|
|
}
|
|
|
|
@Test
|
|
public void testFailure_codeMark() throws Exception {
|
|
thrown.expect(UnsupportedMarkTypeException.class);
|
|
setEppInput("domain_create_code_with_mark.xml");
|
|
persistContactsAndHosts();
|
|
runFlow();
|
|
}
|
|
|
|
@Test
|
|
public void testFailure_signedMark() throws Exception {
|
|
thrown.expect(SignedMarksNotAcceptedInCurrentPhaseException.class);
|
|
setEppInput("domain_create_signed_mark.xml");
|
|
persistContactsAndHosts();
|
|
runFlow();
|
|
}
|
|
|
|
@Test
|
|
public void testFailure_expiredClaim() throws Exception {
|
|
thrown.expect(ExpiredClaimException.class);
|
|
clock.setTo(DateTime.parse("2010-08-17T09:00:00.0Z"));
|
|
setEppInput("domain_create_claim_notice.xml");
|
|
persistContactsAndHosts();
|
|
runFlow();
|
|
}
|
|
|
|
@Test
|
|
public void testFailure_expiredAcceptance() throws Exception {
|
|
thrown.expect(AcceptedTooLongAgoException.class);
|
|
clock.setTo(DateTime.parse("2009-09-16T09:00:00.0Z"));
|
|
setEppInput("domain_create_claim_notice.xml");
|
|
persistContactsAndHosts();
|
|
runFlow();
|
|
}
|
|
|
|
@Test
|
|
public void testFailure_malformedTcnIdWrongLength() throws Exception {
|
|
thrown.expect(MalformedTcnIdException.class);
|
|
clock.setTo(DateTime.parse("2009-08-16T09:00:00.0Z"));
|
|
setEppInput("domain_create_malformed_claim_notice1.xml");
|
|
persistContactsAndHosts();
|
|
runFlow();
|
|
}
|
|
|
|
@Test
|
|
public void testFailure_malformedTcnIdBadChar() throws Exception {
|
|
thrown.expect(MalformedTcnIdException.class);
|
|
clock.setTo(DateTime.parse("2009-08-16T09:00:00.0Z"));
|
|
setEppInput("domain_create_malformed_claim_notice2.xml");
|
|
persistContactsAndHosts();
|
|
runFlow();
|
|
}
|
|
|
|
@Test
|
|
public void testFailure_badTcnIdChecksum() throws Exception {
|
|
thrown.expect(InvalidTcnIdChecksumException.class);
|
|
clock.setTo(DateTime.parse("2009-08-16T09:00:00.0Z"));
|
|
setEppInput("domain_create_bad_checksum_claim_notice.xml");
|
|
persistContactsAndHosts();
|
|
runFlow();
|
|
}
|
|
|
|
@Test
|
|
public void testFailure_premiumBlocked() throws Exception {
|
|
thrown.expect(PremiumNameBlockedException.class);
|
|
createTld("example");
|
|
persistResource(Registry.get("example").asBuilder().setPremiumPriceAckRequired(false).build());
|
|
setEppInput("domain_create_premium.xml");
|
|
persistContactsAndHosts("net");
|
|
// Modify the Registrar to block premium names.
|
|
persistResource(Registrar.loadByClientId("TheRegistrar").asBuilder()
|
|
.setBlockPremiumNames(true)
|
|
.build());
|
|
runFlow();
|
|
}
|
|
|
|
@Test
|
|
public void testFailure_feeNotProvidedOnPremiumName() throws Exception {
|
|
thrown.expect(FeesRequiredForPremiumNameException.class);
|
|
createTld("example");
|
|
setEppInput("domain_create_premium.xml");
|
|
persistContactsAndHosts("net");
|
|
runFlow();
|
|
}
|
|
|
|
@Test
|
|
public void testFailure_omitFeeExtensionOnLogin() throws Exception {
|
|
thrown.expect(UndeclaredServiceExtensionException.class);
|
|
removeServiceExtensionUri(ServiceExtension.FEE_0_6.getUri());
|
|
createTld("net");
|
|
setEppInput("domain_create_fee.xml");
|
|
persistContactsAndHosts();
|
|
runFlow();
|
|
}
|
|
|
|
@Test
|
|
public void testFailure_feeGivenInWrongScale() throws Exception {
|
|
thrown.expect(CurrencyValueScaleException.class);
|
|
setEppInput("domain_create_fee_bad_scale.xml");
|
|
persistContactsAndHosts();
|
|
runFlow();
|
|
}
|
|
|
|
private void doFailingDomainNameTest(
|
|
String domainName,
|
|
Class<? extends Throwable> exception) throws Exception {
|
|
thrown.expect(exception);
|
|
setEppInput("domain_create_uppercase.xml");
|
|
eppLoader.replaceAll("Example.tld", domainName);
|
|
persistContactsAndHosts();
|
|
runFlow();
|
|
}
|
|
|
|
@Test
|
|
public void testFailure_uppercase() throws Exception {
|
|
doFailingDomainNameTest("Example.tld", BadDomainNameCharacterException.class);
|
|
}
|
|
|
|
@Test
|
|
public void testFailure_badCharacter() throws Exception {
|
|
doFailingDomainNameTest("test_example.tld", BadDomainNameCharacterException.class);
|
|
}
|
|
|
|
@Test
|
|
public void testFailure_leadingDash() throws Exception {
|
|
doFailingDomainNameTest("-example.tld", LeadingDashException.class);
|
|
}
|
|
|
|
@Test
|
|
public void testFailure_trailingDash() throws Exception {
|
|
doFailingDomainNameTest("example-.tld", TrailingDashException.class);
|
|
}
|
|
|
|
@Test
|
|
public void testFailure_tooLong() throws Exception {
|
|
doFailingDomainNameTest(Strings.repeat("a", 64) + ".tld", DomainLabelTooLongException.class);
|
|
}
|
|
|
|
@Test
|
|
public void testFailure_leadingDot() throws Exception {
|
|
doFailingDomainNameTest(".example.tld", EmptyDomainNamePartException.class);
|
|
}
|
|
|
|
@Test
|
|
public void testFailure_leadingDotTld() throws Exception {
|
|
doFailingDomainNameTest("foo..tld", EmptyDomainNamePartException.class);
|
|
}
|
|
|
|
@Test
|
|
public void testFailure_tooManyParts() throws Exception {
|
|
doFailingDomainNameTest("foo.example.tld", BadDomainNamePartsCountException.class);
|
|
}
|
|
|
|
@Test
|
|
public void testFailure_tooFewParts() throws Exception {
|
|
doFailingDomainNameTest("tld", BadDomainNamePartsCountException.class);
|
|
}
|
|
|
|
@Test
|
|
public void testFailure_invalidPunycode() throws Exception {
|
|
doFailingDomainNameTest("xn--abcdefg.tld", InvalidPunycodeException.class);
|
|
}
|
|
|
|
@Test
|
|
public void testFailure_dashesInThirdAndFourthPosition() throws Exception {
|
|
doFailingDomainNameTest("ab--cdefg.tld", DashesInThirdAndFourthException.class);
|
|
}
|
|
|
|
@Test
|
|
public void testFailure_tldDoesNotExist() throws Exception {
|
|
doFailingDomainNameTest("foo.nosuchtld", TldDoesNotExistException.class);
|
|
}
|
|
|
|
@Test
|
|
public void testFailure_invalidIdnCodePoints() throws Exception {
|
|
// ❤☀☆☂☻♞☯.tld
|
|
doFailingDomainNameTest("xn--k3hel9n7bxlu1e.tld", InvalidIdnDomainLabelException.class);
|
|
}
|
|
|
|
@Test
|
|
public void testFailure_sunriseRegistration() throws Exception {
|
|
thrown.expect(NoGeneralRegistrationsInCurrentPhaseException.class);
|
|
createTld("tld", TldState.SUNRISE);
|
|
setEppInput("domain_create_registration_sunrise.xml");
|
|
persistContactsAndHosts();
|
|
runFlow();
|
|
}
|
|
|
|
@Test
|
|
public void testSuccess_superuserSunriseRegistration() throws Exception {
|
|
createTld("tld", TldState.SUNRISE);
|
|
setEppInput("domain_create_registration_sunrise.xml");
|
|
persistContactsAndHosts();
|
|
doSuccessfulTest("tld", "domain_create_response.xml", UserPrivileges.SUPERUSER);
|
|
}
|
|
|
|
@Test
|
|
public void testSuccess_qlpSunriseRegistration() throws Exception {
|
|
createTld("tld", TldState.SUNRISE);
|
|
setEppInput("domain_create_registration_qlp_sunrise.xml");
|
|
sessionMetadata.setSessionSource(SessionSource.TOOL); // Only tools can pass in metadata.
|
|
persistContactsAndHosts();
|
|
runFlowAssertResponse(readFile("domain_create_response.xml"));
|
|
assertSuccessfulCreate("tld", true);
|
|
assertNoLordn();
|
|
}
|
|
|
|
@Test
|
|
public void testSuccess_qlpSunriseRegistrationWithEncodedSignedMark() throws Exception {
|
|
createTld("tld", TldState.SUNRISE);
|
|
clock.setTo(DateTime.parse("2014-09-09T09:09:09Z"));
|
|
setEppInput("domain_create_registration_qlp_sunrise_encoded_signed_mark.xml");
|
|
sessionMetadata.setSessionSource(SessionSource.TOOL); // Only tools can pass in metadata.
|
|
persistContactsAndHosts();
|
|
runFlowAssertResponse(readFile("domain_create_response_encoded_signed_mark_name.xml"));
|
|
assertSuccessfulCreate("tld", true);
|
|
assertSunriseLordn();
|
|
}
|
|
|
|
@Test
|
|
public void testSuccess_qlpSunriseRegistrationWithClaimsNotice() throws Exception {
|
|
createTld("tld", TldState.SUNRISE);
|
|
clock.setTo(DateTime.parse("2009-08-16T09:00:00.0Z"));
|
|
setEppInput("domain_create_registration_qlp_sunrise_claims_notice.xml");
|
|
sessionMetadata.setSessionSource(SessionSource.TOOL); // Only tools can pass in metadata.
|
|
persistContactsAndHosts();
|
|
runFlowAssertResponse(readFile("domain_create_response_claims.xml"));
|
|
assertSuccessfulCreate("tld", true);
|
|
assertClaimsLordn();
|
|
}
|
|
|
|
@Test
|
|
public void testFailure_sunrushRegistration() throws Exception {
|
|
thrown.expect(NoGeneralRegistrationsInCurrentPhaseException.class);
|
|
createTld("tld", TldState.SUNRUSH);
|
|
setEppInput("domain_create_registration_sunrush.xml");
|
|
persistContactsAndHosts();
|
|
runFlow();
|
|
}
|
|
|
|
@Test
|
|
public void testFailure_notAuthorizedForTld() throws Exception {
|
|
thrown.expect(NotAuthorizedForTldException.class);
|
|
createTld("irrelevant", "IRR");
|
|
DatastoreHelper.persistResource(
|
|
Registrar.loadByClientId("TheRegistrar")
|
|
.asBuilder()
|
|
.setAllowedTlds(ImmutableSet.<String>of("irrelevant"))
|
|
.build());
|
|
persistContactsAndHosts();
|
|
runFlow();
|
|
}
|
|
|
|
@Test
|
|
public void testSuccess_superuserSunrushRegistration() throws Exception {
|
|
createTld("tld", TldState.SUNRUSH);
|
|
setEppInput("domain_create_registration_sunrush.xml");
|
|
persistContactsAndHosts();
|
|
doSuccessfulTest("tld", "domain_create_response.xml", UserPrivileges.SUPERUSER);
|
|
}
|
|
|
|
@Test
|
|
public void testSuccess_qlpSunrushRegistration() throws Exception {
|
|
createTld("tld", TldState.SUNRUSH);
|
|
setEppInput("domain_create_registration_qlp_sunrush.xml");
|
|
sessionMetadata.setSessionSource(SessionSource.TOOL); // Only tools can pass in metadata.
|
|
persistContactsAndHosts();
|
|
runFlowAssertResponse(readFile("domain_create_response.xml"));
|
|
assertSuccessfulCreate("tld", true);
|
|
assertNoLordn();
|
|
}
|
|
|
|
@Test
|
|
public void testSuccess_qlpSunrushRegistrationWithEncodedSignedMark() throws Exception {
|
|
createTld("tld", TldState.SUNRUSH);
|
|
clock.setTo(DateTime.parse("2014-09-09T09:09:09Z"));
|
|
setEppInput("domain_create_registration_qlp_sunrush_encoded_signed_mark.xml");
|
|
sessionMetadata.setSessionSource(SessionSource.TOOL); // Only tools can pass in metadata.
|
|
persistContactsAndHosts();
|
|
runFlowAssertResponse(readFile("domain_create_response_encoded_signed_mark_name.xml"));
|
|
assertSuccessfulCreate("tld", true);
|
|
assertSunriseLordn();
|
|
}
|
|
|
|
@Test
|
|
public void testSuccess_qlpSunrushRegistrationWithClaimsNotice() throws Exception {
|
|
createTld("tld", TldState.SUNRUSH);
|
|
clock.setTo(DateTime.parse("2009-08-16T09:00:00.0Z"));
|
|
setEppInput("domain_create_registration_qlp_sunrush_claims_notice.xml");
|
|
sessionMetadata.setSessionSource(SessionSource.TOOL); // Only tools can pass in metadata.
|
|
persistContactsAndHosts();
|
|
runFlowAssertResponse(readFile("domain_create_response_claims.xml"));
|
|
assertSuccessfulCreate("tld", true);
|
|
assertClaimsLordn();
|
|
}
|
|
|
|
@Test
|
|
public void testFailure_landrushRegistration() throws Exception {
|
|
thrown.expect(NoGeneralRegistrationsInCurrentPhaseException.class);
|
|
createTld("tld", TldState.LANDRUSH);
|
|
setEppInput("domain_create_registration_landrush.xml");
|
|
persistContactsAndHosts();
|
|
runFlow();
|
|
}
|
|
|
|
@Test
|
|
public void testSuccess_superuserLandrushRegistration() throws Exception {
|
|
createTld("tld", TldState.LANDRUSH);
|
|
setEppInput("domain_create_registration_landrush.xml");
|
|
persistContactsAndHosts();
|
|
doSuccessfulTest("tld", "domain_create_response.xml", UserPrivileges.SUPERUSER);
|
|
}
|
|
|
|
@Test
|
|
public void testSuccess_qlpLandrushRegistration() throws Exception {
|
|
createTld("tld", TldState.LANDRUSH);
|
|
setEppInput("domain_create_registration_qlp_landrush.xml");
|
|
sessionMetadata.setSessionSource(SessionSource.TOOL); // Only tools can pass in metadata.
|
|
persistContactsAndHosts();
|
|
runFlowAssertResponse(readFile("domain_create_response.xml"));
|
|
assertSuccessfulCreate("tld", true);
|
|
assertNoLordn();
|
|
}
|
|
|
|
@Test
|
|
public void testFailure_qlpLandrushRegistrationWithEncodedSignedMark() throws Exception {
|
|
thrown.expect(SignedMarksNotAcceptedInCurrentPhaseException.class);
|
|
createTld("tld", TldState.LANDRUSH);
|
|
clock.setTo(DateTime.parse("2014-09-09T09:09:09Z"));
|
|
setEppInput("domain_create_registration_qlp_landrush_encoded_signed_mark.xml");
|
|
sessionMetadata.setSessionSource(SessionSource.TOOL); // Only tools can pass in metadata.
|
|
persistContactsAndHosts();
|
|
runFlow();
|
|
}
|
|
|
|
@Test
|
|
public void testSuccess_qlpLandrushRegistrationWithClaimsNotice() throws Exception {
|
|
createTld("tld", TldState.LANDRUSH);
|
|
clock.setTo(DateTime.parse("2009-08-16T09:00:00.0Z"));
|
|
setEppInput("domain_create_registration_qlp_landrush_claims_notice.xml");
|
|
sessionMetadata.setSessionSource(SessionSource.TOOL); // Only tools can pass in metadata.
|
|
persistContactsAndHosts();
|
|
runFlowAssertResponse(readFile("domain_create_response_claims.xml"));
|
|
assertSuccessfulCreate("tld", true);
|
|
assertClaimsLordn();
|
|
}
|
|
|
|
@Test
|
|
public void testFailure_registrantNotWhitelisted() throws Exception {
|
|
persistActiveContact("someone");
|
|
persistContactsAndHosts();
|
|
persistResource(Registry.get("tld").asBuilder()
|
|
.setAllowedRegistrantContactIds(ImmutableSet.of("someone"))
|
|
.build());
|
|
thrown.expect(RegistrantNotAllowedException.class);
|
|
runFlow();
|
|
}
|
|
|
|
@Test
|
|
public void testFailure_nameserverNotWhitelisted() throws Exception {
|
|
persistActiveHost("ns1.example.com");
|
|
persistContactsAndHosts();
|
|
persistResource(Registry.get("tld").asBuilder()
|
|
.setAllowedFullyQualifiedHostNames(ImmutableSet.of("ns1.someone.tld"))
|
|
.build());
|
|
thrown.expect(NameserverNotAllowedException.class);
|
|
runFlow();
|
|
}
|
|
|
|
@Test
|
|
public void testSuccess_nameserverAndRegistrantWhitelisted() throws Exception {
|
|
persistResource(Registry.get("tld").asBuilder()
|
|
.setAllowedRegistrantContactIds(ImmutableSet.of("jd1234"))
|
|
.setAllowedFullyQualifiedHostNames(ImmutableSet.of("ns1.example.net", "ns2.example.net"))
|
|
.build());
|
|
persistContactsAndHosts();
|
|
doSuccessfulTest();
|
|
}
|
|
}
|