Make GracePeriod OneTime vs Recurring logic explicit

This CL cleans up some old crufy logic in GracePeriod that overloaded
methods to accept either OneTime or Recurring billing events refs,
despite storing them in separate fields in the entity (since
BillingEvent is not a polymorphic superclass, just a Java-only one,
you can't store them as refs to BillingEvent).

That overloading was ultimately only there as a convenience/hack from
when we added Recurring events and didn't want to go back and change
everything.  It obfuscates what's really going on, requires extra
casting/loss of type-safety, and relies on indirect signals (e.g. the
grace period type being AUTO_RENEW) to guess what the right billing
event type is.  That latter aspect will likely no longer work in a
monthly billing world, and was brittle in any case.

A coming CL will rip the same logic out of Cancellation.
-------------
Created by MOE: https://github.com/google/moe
MOE_MIGRATED_REVID=117164286

javatests/com/google/domain/registry/flows/FlowTestCase.java

@@ -227,7 +227,13 @@ public abstract class FlowTestCase<F extends Flow> {
         new Function<GracePeriod, BillingEvent>() {
           @Override
           public BillingEvent apply(GracePeriod gracePeriod) {
-            return gracePeriod.getBillingEvent().get();
+            assertThat(gracePeriod.hasBillingEvent())
+                .named("Billing event is present for grace period: " + gracePeriod)
+                .isTrue();
+            return firstNonNull(
+                gracePeriod.getOneTimeBillingEvent(),
+                gracePeriod.getRecurringBillingEvent())
+                    .get();
           }};
     assertThat(canonicalizeGracePeriods(Maps.toMap(actual, gracePeriodExpander)))
         .isEqualTo(canonicalizeGracePeriods(expected));

javatests/com/google/domain/registry/flows/domain/DomainDeleteFlowTest.java

@@ -143,7 +143,7 @@ public class DomainDeleteFlowTest extends ResourceFlowTestCase<DomainDeleteFlow,
             .build());
     domain = persistResource(
         domain.asBuilder()
-            .setGracePeriods(ImmutableSet.of(GracePeriod.create(
+            .setGracePeriods(ImmutableSet.of(GracePeriod.createForRecurring(
                 GracePeriodStatus.AUTO_RENEW,
                 A_MONTH_AGO.plusDays(45),
                 "TheRegistrar",

javatests/com/google/domain/registry/flows/domain/DomainInfoFlowTest.java

@@ -32,6 +32,7 @@ import com.google.domain.registry.flows.domain.DomainFlowUtils.BadPeriodUnitExce
 import com.google.domain.registry.flows.domain.DomainFlowUtils.CurrencyUnitMismatchException;
 import com.google.domain.registry.flows.domain.DomainFlowUtils.FeeChecksDontSupportPhasesException;
 import com.google.domain.registry.flows.domain.DomainFlowUtils.RestoresAreAlwaysForOneYearException;
+import com.google.domain.registry.model.billing.BillingEvent.Recurring;
 import com.google.domain.registry.model.contact.ContactAuthInfo;
 import com.google.domain.registry.model.contact.ContactResource;
 import com.google.domain.registry.model.domain.DesignatedContact;
@@ -47,6 +48,7 @@ import com.google.domain.registry.model.eppcommon.StatusValue;
 import com.google.domain.registry.model.host.HostResource;
 import com.google.domain.registry.testing.AppEngineRule;
 
+import com.googlecode.objectify.Key;
 import com.googlecode.objectify.Ref;
 
 import org.joda.time.DateTime;
@@ -278,8 +280,11 @@ public class DomainInfoFlowTest extends ResourceFlowTestCase<DomainInfoFlow, Dom
     persistTestEntities(false);
     // Add an AUTO_RENEW grace period to the saved resource.
     persistResource(domain.asBuilder()
-        .addGracePeriod(GracePeriod.create(
-            GracePeriodStatus.AUTO_RENEW, clock.nowUtc().plusDays(1), "foo", null))
+        .addGracePeriod(GracePeriod.createForRecurring(
+            GracePeriodStatus.AUTO_RENEW,
+            clock.nowUtc().plusDays(1),
+            "foo",
+            Ref.create(Key.create(Recurring.class, 12345))))
         .build());
     doSuccessfulTest("domain_info_response_autorenewperiod.xml", false);
   }

javatests/com/google/domain/registry/model/domain/DomainResourceTest.java

@@ -416,7 +416,7 @@ public class DomainResourceTest extends EntityTestCase {
         .isEqualTo(oldExpirationTime.plusYears(3));
     assertThat(renewedThreeTimes.getLastEppUpdateTime()).isEqualTo(clock.nowUtc());
     assertThat(renewedThreeTimes.getGracePeriods())
-        .containsExactly(GracePeriod.create(
+        .containsExactly(GracePeriod.createForRecurring(
             GracePeriodStatus.AUTO_RENEW,
             oldExpirationTime.plusYears(2).plus(
                 Registry.get("com").getAutoRenewGracePeriodLength()),

javatests/com/google/domain/registry/model/domain/GracePeriodTest.java

@@ -0,0 +1,115 @@
+// Copyright 2016 Google Inc. 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.model.domain;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.joda.time.DateTimeZone.UTC;
+
+import com.google.domain.registry.model.billing.BillingEvent;
+import com.google.domain.registry.model.billing.BillingEvent.Reason;
+import com.google.domain.registry.model.billing.BillingEvent.Recurring;
+import com.google.domain.registry.model.domain.rgp.GracePeriodStatus;
+import com.google.domain.registry.model.reporting.HistoryEntry;
+import com.google.domain.registry.testing.AppEngineRule;
+import com.google.domain.registry.testing.ExceptionRule;
+
+import com.googlecode.objectify.Key;
+import com.googlecode.objectify.Ref;
+
+import org.joda.money.CurrencyUnit;
+import org.joda.money.Money;
+import org.joda.time.DateTime;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests for {@link GracePeriod}. */
+@RunWith(JUnit4.class)
+public class GracePeriodTest {
+
+  @Rule
+  public final AppEngineRule appEngine = AppEngineRule.builder()
+      .withDatastore()  // Needed to be able to construct Keys.
+      .build();
+
+  @Rule
+  public final ExceptionRule thrown = new ExceptionRule();
+
+  private final DateTime now = DateTime.now(UTC);
+  private BillingEvent.OneTime onetime;
+
+  @Before
+  public void before() {
+    onetime = new BillingEvent.OneTime.Builder()
+      .setEventTime(now)
+      .setBillingTime(now.plusDays(1))
+      .setClientId("TheRegistrar")
+      .setCost(Money.of(CurrencyUnit.USD, 42))
+      .setParent(Key.create(HistoryEntry.class, 12345))
+      .setReason(Reason.CREATE)
+      .setPeriodYears(1)
+      .setTargetId("foo.google")
+      .build();
+  }
+
+  @Test
+  public void testSuccess_forBillingEvent() {
+    GracePeriod gracePeriod = GracePeriod.forBillingEvent(GracePeriodStatus.ADD, onetime);
+    assertThat(gracePeriod.getType()).isEqualTo(GracePeriodStatus.ADD);
+    assertThat(gracePeriod.getOneTimeBillingEvent()).isEqualTo(Ref.create(onetime));
+    assertThat(gracePeriod.getRecurringBillingEvent()).isNull();
+    assertThat(gracePeriod.getClientId()).isEqualTo("TheRegistrar");
+    assertThat(gracePeriod.getExpirationTime()).isEqualTo(now.plusDays(1));
+    assertThat(gracePeriod.isSunrushAddGracePeriod()).isFalse();
+    assertThat(gracePeriod.hasBillingEvent()).isTrue();
+  }
+
+  @Test
+  public void testSuccess_forBillingEvent_sunrushAdd() {
+    GracePeriod gracePeriod = GracePeriod.forBillingEvent(GracePeriodStatus.SUNRUSH_ADD, onetime);
+    assertThat(gracePeriod.getType()).isEqualTo(GracePeriodStatus.ADD);
+    assertThat(gracePeriod.isSunrushAddGracePeriod()).isTrue();
+  }
+
+  @Test
+  public void testSuccess_createWithoutBillingEvent() {
+    GracePeriod gracePeriod = GracePeriod.createWithoutBillingEvent(
+        GracePeriodStatus.REDEMPTION, now, "TheRegistrar");
+    assertThat(gracePeriod.getType()).isEqualTo(GracePeriodStatus.REDEMPTION);
+    assertThat(gracePeriod.getOneTimeBillingEvent()).isNull();
+    assertThat(gracePeriod.getRecurringBillingEvent()).isNull();
+    assertThat(gracePeriod.getClientId()).isEqualTo("TheRegistrar");
+    assertThat(gracePeriod.getExpirationTime()).isEqualTo(now);
+    assertThat(gracePeriod.hasBillingEvent()).isFalse();
+  }
+
+  @Test
+  public void testFailure_forBillingEvent_autoRenew() {
+    thrown.expect(IllegalArgumentException.class, "autorenew");
+    GracePeriod.forBillingEvent(GracePeriodStatus.AUTO_RENEW, onetime);
+  }
+
+  @Test
+  public void testFailure_createForRecurring_notAutoRenew() {
+    thrown.expect(IllegalArgumentException.class, "autorenew");
+    GracePeriod.createForRecurring(
+        GracePeriodStatus.RENEW,
+        now.plusDays(1),
+        "TheRegistrar",
+        Ref.create(Key.create(Recurring.class, 12345)));
+  }
+}