From 4e0b6d36c4445044cf633b94414a4047cd739cf1 Mon Sep 17 00:00:00 2001 From: ctingue Date: Wed, 12 Oct 2016 13:51:28 -0700 Subject: [PATCH] Change lrpTldStates to Interval ------------- Created by MOE: https://github.com/google/moe MOE_MIGRATED_REVID=135957698 --- .../flows/domain/BaseDomainCreateFlow.java | 3 +- .../registry/model/ofy/ObjectifyService.java | 8 +- .../registry/model/registry/Registry.java | 35 +++++--- .../tools/CreateOrUpdateTldCommand.java | 17 ++-- .../tools/params/IntervalParameter.java | 41 ++++++++++ .../params/OptionalIntervalParameter.java | 21 +++++ .../tools/params/ParameterFactory.java | 2 + .../DomainApplicationCreateFlowTest.java | 17 ++-- .../registry/model/registry/RegistryTest.java | 17 ---- javatests/google/registry/model/schema.txt | 3 +- .../registry/tools/CreateTldCommandTest.java | 43 +++------- .../registry/tools/UpdateTldCommandTest.java | 76 ++++++------------ .../tools/params/IntervalParameterTest.java | 80 +++++++++++++++++++ 13 files changed, 232 insertions(+), 131 deletions(-) create mode 100644 java/google/registry/tools/params/IntervalParameter.java create mode 100644 java/google/registry/tools/params/OptionalIntervalParameter.java create mode 100644 javatests/google/registry/tools/params/IntervalParameterTest.java diff --git a/java/google/registry/flows/domain/BaseDomainCreateFlow.java b/java/google/registry/flows/domain/BaseDomainCreateFlow.java index 2e5395392..8d2175a1b 100644 --- a/java/google/registry/flows/domain/BaseDomainCreateFlow.java +++ b/java/google/registry/flows/domain/BaseDomainCreateFlow.java @@ -201,7 +201,8 @@ public abstract class BaseDomainCreateFlow translatorFactory : Arrays.asList( - new ReadableInstantUtcTranslatorFactory(), new CidrAddressBlockTranslatorFactory(), + new CommitLogRevisionsTranslatorFactory(), + new CreateAutoTimestampTranslatorFactory(), new CurrencyUnitTranslatorFactory(), new DurationTranslatorFactory(), new InetAddressTranslatorFactory(), new MoneyStringTranslatorFactory(), - new CreateAutoTimestampTranslatorFactory(), - new UpdateAutoTimestampTranslatorFactory(), - new CommitLogRevisionsTranslatorFactory())) { + new ReadableInstantUtcTranslatorFactory(), + new UpdateAutoTimestampTranslatorFactory())) { factory().getTranslators().add(translatorFactory); } } diff --git a/java/google/registry/model/registry/Registry.java b/java/google/registry/model/registry/Registry.java index 75569a9e0..56fc92866 100644 --- a/java/google/registry/model/registry/Registry.java +++ b/java/google/registry/model/registry/Registry.java @@ -62,10 +62,12 @@ import google.registry.model.registry.label.PremiumList; import google.registry.model.registry.label.ReservedList; import google.registry.util.Idn; import java.util.Set; +import javax.annotation.Nullable; import org.joda.money.CurrencyUnit; import org.joda.money.Money; import org.joda.time.DateTime; import org.joda.time.Duration; +import org.joda.time.Interval; /** Persisted per-TLD configuration data. */ @Cache(expirationSeconds = RECOMMENDED_MEMCACHE_EXPIRATION) @@ -368,15 +370,26 @@ public class Registry extends ImmutableObject implements Buildable { /** The end of the claims period (at or after this time, claims no longer applies). */ DateTime claimsPeriodEnd = END_OF_TIME; + /** + * The (inclusive) start {@link DateTime} of LRP. This (and lrpPeriodEnd) exist for serialization + * purposes, though everything else that interacts with the LRP period should use getLrpPeriod() + * and setLrpPeriod(), which uses an {@link Interval}. + */ + DateTime lrpPeriodStart; + + /** + * The (exclusive) end {@link DateTime} of LRP. This (and lrpPeriodStart) exist for serialization + * purposes, though everything else that interacts with the LRP period should use getLrpPeriod() + * and setLrpPeriod(), which uses an {@link Interval}. + */ + DateTime lrpPeriodEnd; + /** A whitelist of clients allowed to be used on domains on this TLD (ignored if empty). */ Set allowedRegistrantContactIds; /** A whitelist of hosts allowed to be used on domains on this TLD (ignored if empty). */ Set allowedFullyQualifiedHostNames; - /** The set of {@link TldState}s for which LRP applications are accepted (ignored if empty). */ - Set lrpTldStates; - public String getTldStr() { return tldStr; } @@ -558,8 +571,11 @@ public class Registry extends ImmutableObject implements Buildable { return nullToEmptyImmutableCopy(allowedFullyQualifiedHostNames); } - public ImmutableSet getLrpTldStates() { - return nullToEmptyImmutableCopy(lrpTldStates); + @Nullable + public Interval getLrpPeriod() { + return (lrpPeriodStart == null && lrpPeriodEnd == null) + ? null + : new Interval(lrpPeriodStart, lrpPeriodEnd); } @Override @@ -818,8 +834,9 @@ public class Registry extends ImmutableObject implements Buildable { return this; } - public Builder setLrpTldStates(ImmutableSet lrpTldStates) { - getInstance().lrpTldStates = lrpTldStates; + public Builder setLrpPeriod(@Nullable Interval lrpPeriod) { + getInstance().lrpPeriodStart = (lrpPeriod == null ? null : lrpPeriod.getStart()); + getInstance().lrpPeriodEnd = (lrpPeriod == null ? null : lrpPeriod.getEnd()); return this; } @@ -840,10 +857,6 @@ public class Registry extends ImmutableObject implements Buildable { // cloned it into a new builder, to block re-building a Registry in an invalid state. instance.tldStateTransitions.checkValidity(); instance.renewBillingCostTransitions.checkValidity(); - checkArgument( - instance.tldStateTransitions.toValueMap().values() - .containsAll(instance.getLrpTldStates()), - "Cannot specify an LRP TLD state that is not part of the TLD state transitions."); instance.eapFeeSchedule.checkValidity(); // All costs must be in the expected currency. // TODO(b/21854155): When we move PremiumList into datastore, verify its currency too. diff --git a/java/google/registry/tools/CreateOrUpdateTldCommand.java b/java/google/registry/tools/CreateOrUpdateTldCommand.java index aebd20b60..09448f592 100644 --- a/java/google/registry/tools/CreateOrUpdateTldCommand.java +++ b/java/google/registry/tools/CreateOrUpdateTldCommand.java @@ -32,8 +32,8 @@ import google.registry.model.registry.Registry; import google.registry.model.registry.Registry.TldState; import google.registry.model.registry.Registry.TldType; import google.registry.model.registry.label.PremiumList; +import google.registry.tools.params.OptionalIntervalParameter; import google.registry.tools.params.OptionalStringParameter; -import google.registry.tools.params.TldStateParameter; import google.registry.tools.params.TransitionListParameter.BillingCostTransitions; import google.registry.tools.params.TransitionListParameter.TldStateTransitions; import java.util.List; @@ -45,6 +45,7 @@ import javax.inject.Named; import org.joda.money.Money; import org.joda.time.DateTime; import org.joda.time.Duration; +import org.joda.time.Interval; /** Shared base class for commands to create or update a TLD. */ abstract class CreateOrUpdateTldCommand extends MutatingCommand { @@ -220,10 +221,12 @@ abstract class CreateOrUpdateTldCommand extends MutatingCommand { @Nullable @Parameter( - names = "--lrp_tld_states", - converter = TldStateParameter.class, - description = "A comma-separated list of TLD states for which LRP is available") - List lrpTldStates; + names = "--lrp_period", + description = + "LRP period (in ISO-8601 format, e.g. 2004-06-09T12:30:00Z/2004-07-10T13:30:00Z", + converter = OptionalIntervalParameter.class, + validateWith = OptionalIntervalParameter.class) + private Optional lrpPeriod; /** Returns the existing registry (for update) or null (for creates). */ @Nullable @@ -391,8 +394,8 @@ abstract class CreateOrUpdateTldCommand extends MutatingCommand { } } - if (lrpTldStates != null) { - builder.setLrpTldStates(ImmutableSet.copyOf(lrpTldStates)); + if (lrpPeriod != null) { + builder.setLrpPeriod(lrpPeriod.orNull()); } ImmutableSet newReservedListNames = getReservedLists(oldRegistry); diff --git a/java/google/registry/tools/params/IntervalParameter.java b/java/google/registry/tools/params/IntervalParameter.java new file mode 100644 index 000000000..2331255d5 --- /dev/null +++ b/java/google/registry/tools/params/IntervalParameter.java @@ -0,0 +1,41 @@ +// Copyright 2016 The Nomulus Authors. All Rights Reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package google.registry.tools.params; + +import org.joda.time.DateTimeZone; +import org.joda.time.Interval; + +/** Interval CLI parameter converter/validator. */ +public final class IntervalParameter extends ParameterConverterValidator { + + public IntervalParameter() { + super("not an ISO-8601 interval (e.g. 2004-06-09T12:30:00Z/2004-07-10T13:30:00Z)"); + } + + @Override + public Interval convert(String value) { + // Interval.parse(null) creates an interval with both start and end times set to now. + // Do something a little more reasonable. + if (value == null) { + throw new NullPointerException(); + } + Interval interval = Interval.parse(value); + // Interval does not have a way to set the time zone, so create a new interval with the + // start and end times of the parsed interval converted to UTC. + return new Interval( + interval.getStart().withZone(DateTimeZone.UTC), + interval.getEnd().withZone(DateTimeZone.UTC)); + } +} diff --git a/java/google/registry/tools/params/OptionalIntervalParameter.java b/java/google/registry/tools/params/OptionalIntervalParameter.java new file mode 100644 index 000000000..1c6217d14 --- /dev/null +++ b/java/google/registry/tools/params/OptionalIntervalParameter.java @@ -0,0 +1,21 @@ +// Copyright 2016 The Nomulus Authors. All Rights Reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package google.registry.tools.params; + +import org.joda.time.Interval; + +/** Optional wrapper for IntervalParameter. */ +public final class OptionalIntervalParameter + extends OptionalParameterConverterValidator {} diff --git a/java/google/registry/tools/params/ParameterFactory.java b/java/google/registry/tools/params/ParameterFactory.java index e23cf708f..fa6fc7697 100644 --- a/java/google/registry/tools/params/ParameterFactory.java +++ b/java/google/registry/tools/params/ParameterFactory.java @@ -26,6 +26,7 @@ import javax.annotation.Nullable; import org.joda.money.Money; import org.joda.time.DateTime; import org.joda.time.Duration; +import org.joda.time.Interval; import org.joda.time.LocalDate; import org.joda.time.YearMonth; @@ -46,6 +47,7 @@ public final class ParameterFactory implements IStringConverterFactory { .put(Duration.class, DurationParameter.class) .put(HostAndPort.class, HostAndPortParameter.class) .put(InternetDomainName.class, InternetDomainNameParameter.class) + .put(Interval.class, IntervalParameter.class) .put(Level.class, LoggingLevelParameter.class) .put(LocalDate.class, LocalDateParameter.class) .put(Money.class, MoneyParameter.class) diff --git a/javatests/google/registry/flows/domain/DomainApplicationCreateFlowTest.java b/javatests/google/registry/flows/domain/DomainApplicationCreateFlowTest.java index 7a782185c..b9285e9f7 100644 --- a/javatests/google/registry/flows/domain/DomainApplicationCreateFlowTest.java +++ b/javatests/google/registry/flows/domain/DomainApplicationCreateFlowTest.java @@ -125,6 +125,7 @@ import java.util.List; import org.joda.money.CurrencyUnit; import org.joda.money.Money; import org.joda.time.DateTime; +import org.joda.time.Interval; import org.junit.Before; import org.junit.Ignore; import org.junit.Rule; @@ -876,7 +877,7 @@ public class DomainApplicationCreateFlowTest public void testSuccess_landrushLrpApplication() throws Exception { createTld("tld", TldState.LANDRUSH); persistResource(Registry.get("tld").asBuilder() - .setLrpTldStates(ImmutableSet.of(TldState.LANDRUSH)) + .setLrpPeriod(new Interval(clock.nowUtc().minusDays(1), clock.nowUtc().plusDays(1))) .build()); LrpTokenEntity token = persistResource( new LrpTokenEntity.Builder() @@ -895,7 +896,7 @@ public class DomainApplicationCreateFlowTest public void testSuccess_landrush_duringLrpWithMissingToken() throws Exception { createTld("tld", TldState.LANDRUSH); persistResource(Registry.get("tld").asBuilder() - .setLrpTldStates(ImmutableSet.of(TldState.LANDRUSH)) + .setLrpPeriod(new Interval(clock.nowUtc().minusDays(1), clock.nowUtc().plusDays(1))) .build()); setEppInput("domain_create_landrush.xml"); persistContactsAndHosts(); @@ -909,7 +910,7 @@ public class DomainApplicationCreateFlowTest // as non-superuser). createTld("tld", TldState.LANDRUSH); persistResource(Registry.get("tld").asBuilder() - .setLrpTldStates(ImmutableSet.of(TldState.LANDRUSH)) + .setLrpPeriod(new Interval(clock.nowUtc().minusDays(1), clock.nowUtc().plusDays(1))) .build()); LrpTokenEntity token = persistResource( new LrpTokenEntity.Builder() @@ -928,7 +929,7 @@ public class DomainApplicationCreateFlowTest public void testFailure_landrushLrpApplication_badToken() throws Exception { createTld("tld", TldState.LANDRUSH); persistResource(Registry.get("tld").asBuilder() - .setLrpTldStates(ImmutableSet.of(TldState.LANDRUSH)) + .setLrpPeriod(new Interval(clock.nowUtc().minusDays(1), clock.nowUtc().plusDays(1))) .build()); persistResource(new LrpTokenEntity.Builder() .setToken("lrptokentest2") @@ -946,7 +947,7 @@ public class DomainApplicationCreateFlowTest public void testFailure_landrushLrpApplication_tokenForWrongTld() throws Exception { createTld("tld", TldState.LANDRUSH); persistResource(Registry.get("tld").asBuilder() - .setLrpTldStates(ImmutableSet.of(TldState.LANDRUSH)) + .setLrpPeriod(new Interval(clock.nowUtc().minusDays(1), clock.nowUtc().plusDays(1))) .build()); persistResource(new LrpTokenEntity.Builder() .setToken("lrptokentest") @@ -967,7 +968,7 @@ public class DomainApplicationCreateFlowTest public void testFailure_landrushLrpApplication_usedToken() throws Exception { createTld("tld", TldState.LANDRUSH); persistResource(Registry.get("tld").asBuilder() - .setLrpTldStates(ImmutableSet.of(TldState.LANDRUSH)) + .setLrpPeriod(new Interval(clock.nowUtc().minusDays(1), clock.nowUtc().plusDays(1))) .build()); persistResource(new LrpTokenEntity.Builder() .setToken("lrptokentest") @@ -1003,10 +1004,10 @@ public class DomainApplicationCreateFlowTest } @Test - public void testSuccess_landrushApplicationWithLrpToken_differentLrpState() throws Exception { + public void testSuccess_landrushApplicationWithLrpToken_noLongerLrp() throws Exception { createTld("tld"); persistResource(Registry.get("tld").asBuilder() - .setLrpTldStates(ImmutableSet.of(TldState.SUNRISE)) + .setLrpPeriod(new Interval(clock.nowUtc().minusDays(2), clock.nowUtc().minusDays(1))) .setTldStateTransitions(ImmutableSortedMap.of( START_OF_TIME, TldState.SUNRISE, clock.nowUtc(), TldState.LANDRUSH)) diff --git a/javatests/google/registry/model/registry/RegistryTest.java b/javatests/google/registry/model/registry/RegistryTest.java index 3136b028f..0d5eb715a 100644 --- a/javatests/google/registry/model/registry/RegistryTest.java +++ b/javatests/google/registry/model/registry/RegistryTest.java @@ -445,21 +445,4 @@ public class RegistryTest extends EntityTestCase { .setEapFeeSchedule(ImmutableSortedMap.of(START_OF_TIME, Money.zero(EUR))) .build(); } - - @Test - public void testFailure_lrpTldState_notInTransitions() { - Registry registry = Registry.get("tld").asBuilder() - .setTldStateTransitions(ImmutableSortedMap.naturalOrder() - .put(START_OF_TIME, TldState.PREDELEGATION) - .put(clock.nowUtc().plusMonths(1), TldState.SUNRISE) - .put(clock.nowUtc().plusMonths(3), TldState.LANDRUSH) - .put(clock.nowUtc().plusMonths(4), TldState.QUIET_PERIOD) - .put(clock.nowUtc().plusMonths(5), TldState.GENERAL_AVAILABILITY) - .build()) - .build(); - thrown.expect( - IllegalArgumentException.class, - "Cannot specify an LRP TLD state that is not part of the TLD state transitions."); - registry.asBuilder().setLrpTldStates(ImmutableSet.of(TldState.SUNRUSH)).build(); - } } diff --git a/javatests/google/registry/model/schema.txt b/javatests/google/registry/model/schema.txt index f1dc04622..dd1006d4c 100644 --- a/javatests/google/registry/model/schema.txt +++ b/javatests/google/registry/model/schema.txt @@ -693,7 +693,6 @@ class google.registry.model.registry.Registry { java.lang.String tldStr; java.lang.String tldUnicode; java.util.Set> reservedLists; - java.util.Set lrpTldStates; java.util.Set allowedFullyQualifiedHostNames; java.util.Set allowedRegistrantContactIds; org.joda.money.CurrencyUnit currency; @@ -701,6 +700,8 @@ class google.registry.model.registry.Registry { org.joda.money.Money restoreBillingCost; org.joda.money.Money serverStatusChangeBillingCost; org.joda.time.DateTime claimsPeriodEnd; + org.joda.time.DateTime lrpPeriodEnd; + org.joda.time.DateTime lrpPeriodStart; org.joda.time.Duration addGracePeriodLength; org.joda.time.Duration anchorTenantAddGracePeriodLength; org.joda.time.Duration autoRenewGracePeriodLength; diff --git a/javatests/google/registry/tools/CreateTldCommandTest.java b/javatests/google/registry/tools/CreateTldCommandTest.java index 136793429..bc82ad88a 100644 --- a/javatests/google/registry/tools/CreateTldCommandTest.java +++ b/javatests/google/registry/tools/CreateTldCommandTest.java @@ -35,6 +35,7 @@ import java.io.PrintStream; import java.math.BigDecimal; import org.joda.money.Money; import org.joda.time.DateTime; +import org.joda.time.Interval; import org.junit.Before; import org.junit.Test; @@ -214,25 +215,14 @@ public class CreateTldCommandTest extends CommandTestCase { } @Test - public void testSuccess_addLrpTldState() throws Exception { + public void testSuccess_addLrpPeriod() throws Exception { runCommandForced( - "--lrp_tld_states=SUNRISE", - "--initial_tld_state=SUNRISE", + "--lrp_period=2004-06-09T12:30:00Z/2004-07-10T13:30:00Z", "--roid_suffix=Q9JYB4C", "xn--q9jyb4c"); - assertThat(Registry.get("xn--q9jyb4c").getLrpTldStates()).containsExactly(TldState.SUNRISE); - } - - @Test - public void testSuccess_addMultipleLrpTldStates() throws Exception { - DateTime now = DateTime.now(UTC); - runCommandForced( - "--lrp_tld_states=SUNRISE,LANDRUSH", - String.format("--tld_state_transitions=%s=SUNRISE,%s=LANDRUSH", START_OF_TIME, now.plus(1)), - "--roid_suffix=Q9JYB4C", - "xn--q9jyb4c"); - assertThat(Registry.get("xn--q9jyb4c").getLrpTldStates()) - .containsExactly(TldState.SUNRISE, TldState.LANDRUSH); + assertThat(Registry.get("xn--q9jyb4c").getLrpPeriod()).isEqualTo( + new Interval( + DateTime.parse("2004-06-09T12:30:00Z"), DateTime.parse("2004-07-10T13:30:00Z"))); } @Test @@ -434,27 +424,20 @@ public class CreateTldCommandTest extends CommandTestCase { } @Test - public void testFailure_lrpTldState_notInTldStateTransitions() throws Exception { + public void testFailure_addLrpPeriod_backwardsInterval() throws Exception { thrown.expect( - IllegalArgumentException.class, - "Cannot specify an LRP TLD state that is not part of the TLD state transitions."); + ParameterException.class, + "--lrp_period=2005-06-09T12:30:00Z/2004-07-10T13:30:00Z not an ISO-8601 interval"); runCommandForced( - "--lrp_tld_states=SUNRISE", - "--initial_tld_state=PREDELEGATION", + "--lrp_period=2005-06-09T12:30:00Z/2004-07-10T13:30:00Z", "--roid_suffix=Q9JYB4C", "xn--q9jyb4c"); } @Test - public void testFailure_lrpTldState_badTldState() throws Exception { - thrown.expect( - IllegalArgumentException.class, - "No enum constant google.registry.model.registry.Registry.TldState.LANDRISE"); - runCommandForced( - "--lrp_tld_states=LANDRISE", - "--initial_tld_state=PREDELEGATION", - "--roid_suffix=Q9JYB4C", - "xn--q9jyb4c"); + public void testFailure_addLrpPeriod_badInterval() throws Exception { + thrown.expect(ParameterException.class, "--lrp_period=foobar not an ISO-8601 interval"); + runCommandForced("--lrp_period=foobar", "--roid_suffix=Q9JYB4C", "xn--q9jyb4c"); } private void runSuccessfulReservedListsTest(String reservedLists) throws Exception { diff --git a/javatests/google/registry/tools/UpdateTldCommandTest.java b/javatests/google/registry/tools/UpdateTldCommandTest.java index c01ab5f64..1b132f425 100644 --- a/javatests/google/registry/tools/UpdateTldCommandTest.java +++ b/javatests/google/registry/tools/UpdateTldCommandTest.java @@ -39,6 +39,7 @@ import java.io.ByteArrayOutputStream; import java.io.PrintStream; import org.joda.money.Money; import org.joda.time.DateTime; +import org.joda.time.Interval; import org.junit.Before; import org.junit.Test; @@ -405,6 +406,17 @@ public class UpdateTldCommandTest extends CommandTestCase { .containsExactly("ns2.example.com"); } + @Test + public void testSuccess_removeLrpPeriod() throws Exception { + persistResource( + Registry.get("xn--q9jyb4c").asBuilder() + .setLrpPeriod(new Interval( + DateTime.parse("2004-06-09T12:30:00Z"), DateTime.parse("2004-07-10T13:30:00Z"))) + .build()); + runCommandForced("--lrp_period=null", "xn--q9jyb4c"); + assertThat(Registry.get("xn--q9jyb4c").getLrpPeriod()).isNull(); + } + @Test public void testFailure_invalidAddGracePeriod() throws Exception { thrown.expect(IllegalArgumentException.class); @@ -815,65 +827,25 @@ public class UpdateTldCommandTest extends CommandTestCase { } @Test - public void testSuccess_updateLrpTldState() throws Exception { - persistResource( - Registry.get("xn--q9jyb4c").asBuilder() - .setTldStateTransitions( - ImmutableSortedMap.of( - START_OF_TIME, TldState.PREDELEGATION, - now.minusMonths(2), TldState.SUNRISE, - now.minusMonths(1), TldState.LANDRUSH, - now, TldState.GENERAL_AVAILABILITY)) - .setLrpTldStates(ImmutableSet.of(TldState.SUNRISE)) - .build()); - runCommandForced("--lrp_tld_states=LANDRUSH", "xn--q9jyb4c"); - assertThat(Registry.get("xn--q9jyb4c").getLrpTldStates()).containsExactly(TldState.LANDRUSH); + public void testSuccess_updateLrpPeriod() throws Exception { + runCommandForced("--lrp_period=2004-06-09T12:30:00Z/2004-07-10T13:30:00Z", "xn--q9jyb4c"); + assertThat(Registry.get("xn--q9jyb4c").getLrpPeriod()).isEqualTo( + new Interval( + DateTime.parse("2004-06-09T12:30:00Z"), DateTime.parse("2004-07-10T13:30:00Z"))); } @Test - public void testSuccess_updateMultipleLrpTldStates() throws Exception { - persistResource( - Registry.get("xn--q9jyb4c").asBuilder() - .setTldStateTransitions( - ImmutableSortedMap.of( - START_OF_TIME, TldState.PREDELEGATION, - now.minusMonths(2), TldState.SUNRISE, - now.minusMonths(1), TldState.LANDRUSH, - now, TldState.GENERAL_AVAILABILITY)) - .setLrpTldStates(ImmutableSet.of()) - .build()); - runCommandForced("--lrp_tld_states=SUNRISE,LANDRUSH", "xn--q9jyb4c"); - assertThat(Registry.get("xn--q9jyb4c").getLrpTldStates()) - .containsExactly(TldState.LANDRUSH, TldState.SUNRISE); - } - - @Test - public void testFailure_updateLrpTldStates_notInTransitions() throws Exception { - persistResource( - Registry.get("xn--q9jyb4c").asBuilder() - .setTldStateTransitions( - ImmutableSortedMap.of( - START_OF_TIME, TldState.PREDELEGATION, - now.minusMonths(2), TldState.SUNRISE, - now, TldState.GENERAL_AVAILABILITY)) - .setLrpTldStates(ImmutableSet.of(TldState.SUNRISE)) - .build()); + public void testFailure_updateLrpPeriod_backwardsInterval() throws Exception { thrown.expect( - IllegalArgumentException.class, - "Cannot specify an LRP TLD state that is not part of the TLD state transitions."); - runCommandForced("--lrp_tld_states=LANDRUSH", "xn--q9jyb4c"); + ParameterException.class, + "--lrp_period=2005-06-09T12:30:00Z/2004-07-10T13:30:00Z not an ISO-8601 interval"); + runCommandForced("--lrp_period=2005-06-09T12:30:00Z/2004-07-10T13:30:00Z", "xn--q9jyb4c"); } @Test - public void testFailure_updateLrpTldStates_badTldState() throws Exception { - thrown.expect( - IllegalArgumentException.class, - "No enum constant google.registry.model.registry.Registry.TldState.LOUD_PERIOD"); - runCommandForced( - "--lrp_tld_states=LOUD_PERIOD", - "--initial_tld_state=PREDELEGATION", - "--roid_suffix=Q9JYB4C", - "xn--q9jyb4c"); + public void testFailure_updateLrpPeriod_badInterval() throws Exception { + thrown.expect(ParameterException.class, "--lrp_period=foobar not an ISO-8601 interval"); + runCommandForced("--lrp_period=foobar", "xn--q9jyb4c"); } private void runSuccessfulReservedListsTest(String reservedLists) throws Exception { diff --git a/javatests/google/registry/tools/params/IntervalParameterTest.java b/javatests/google/registry/tools/params/IntervalParameterTest.java new file mode 100644 index 000000000..68680da0d --- /dev/null +++ b/javatests/google/registry/tools/params/IntervalParameterTest.java @@ -0,0 +1,80 @@ +// Copyright 2016 The Nomulus Authors. All Rights Reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package google.registry.tools.params; + +import static com.google.common.truth.Truth.assertThat; + +import com.beust.jcommander.ParameterException; +import google.registry.testing.ExceptionRule; +import org.joda.time.DateTime; +import org.joda.time.Interval; +import org.junit.Rule; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + +/** Unit tests for {@link IntervalParameter}. */ +@RunWith(JUnit4.class) +public class IntervalParameterTest { + + @Rule + public final ExceptionRule thrown = new ExceptionRule(); + + private final IntervalParameter instance = new IntervalParameter(); + + @Test + public void testConvert() throws Exception { + assertThat(instance.convert("2004-06-09T12:30:00Z/2004-07-10T13:30:00Z")) + .isEqualTo(new Interval( + DateTime.parse("2004-06-09T12:30:00Z"), + DateTime.parse("2004-07-10T13:30:00Z"))); + } + + @Test + public void testConvert_singleDate() throws Exception { + thrown.expect(IllegalArgumentException.class); + instance.convert("2004-06-09T12:30:00Z"); + } + + @Test + public void testConvert_backwardsInterval() throws Exception { + thrown.expect(IllegalArgumentException.class); + instance.convert("2004-07-10T13:30:00Z/2004-06-09T12:30:00Z"); + } + + @Test + public void testConvert_empty_throws() throws Exception { + thrown.expect(IllegalArgumentException.class); + instance.convert(""); + } + + @Test + public void testConvert_null_throws() throws Exception { + thrown.expect(NullPointerException.class); + instance.convert(null); + } + + @Test + public void testConvert_sillyString_throws() throws Exception { + thrown.expect(IllegalArgumentException.class); + instance.convert("foo"); + } + + @Test + public void testValidate_sillyString_throws() throws Exception { + thrown.expect(ParameterException.class, "--time=foo not an"); + instance.validate("--time", "foo"); + } +}