mirror of
https://github.com/google/nomulus.git
synced 2025-05-02 04:57:51 +02:00
e2528875b2
This eliminates the use of Objectify polymorphism for EPP resources entirely (yay!), which makes the Registry 3.0 database migration easier. It is unfortunate that the naming parallelism of EppResources is lost between ContactResource, HostResource, and DomainResource, but the actual type as far as Datastore was concerned was DomainBase all along, and it would be a much more substantial data migration to allow us to continue using the class name DomainResource now that we're no longer using Objectify polymorphism. This simply isn't worth it. This also removes the polymorphic Datastore indexes (which will no longer function as of this change). The non-polymorphic replacement indexes were added in [] ------------- Created by MOE: https://github.com/google/moe MOE_MIGRATED_REVID=230930546
677 lines
29 KiB
Java
677 lines
29 KiB
Java
// Copyright 2017 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.batch;
|
|
|
|
import static com.google.common.truth.Truth.assertThat;
|
|
import static google.registry.model.common.Cursor.CursorType.RECURRING_BILLING;
|
|
import static google.registry.model.domain.Period.Unit.YEARS;
|
|
import static google.registry.model.ofy.ObjectifyService.ofy;
|
|
import static google.registry.model.reporting.HistoryEntry.Type.DOMAIN_AUTORENEW;
|
|
import static google.registry.testing.DatastoreHelper.assertBillingEvents;
|
|
import static google.registry.testing.DatastoreHelper.assertBillingEventsForResource;
|
|
import static google.registry.testing.DatastoreHelper.createTld;
|
|
import static google.registry.testing.DatastoreHelper.getHistoryEntriesOfType;
|
|
import static google.registry.testing.DatastoreHelper.getOnlyHistoryEntryOfType;
|
|
import static google.registry.testing.DatastoreHelper.persistActiveDomain;
|
|
import static google.registry.testing.DatastoreHelper.persistDeletedDomain;
|
|
import static google.registry.testing.DatastoreHelper.persistPremiumList;
|
|
import static google.registry.testing.DatastoreHelper.persistResource;
|
|
import static google.registry.testing.JUnitBackports.assertThrows;
|
|
import static google.registry.util.DateTimeUtils.END_OF_TIME;
|
|
import static google.registry.util.DateTimeUtils.START_OF_TIME;
|
|
import static org.joda.money.CurrencyUnit.USD;
|
|
|
|
import com.google.common.collect.ImmutableSet;
|
|
import com.google.common.collect.ImmutableSortedMap;
|
|
import com.google.common.collect.Iterables;
|
|
import com.googlecode.objectify.Key;
|
|
import google.registry.model.billing.BillingEvent;
|
|
import google.registry.model.billing.BillingEvent.Flag;
|
|
import google.registry.model.billing.BillingEvent.OneTime;
|
|
import google.registry.model.billing.BillingEvent.Reason;
|
|
import google.registry.model.common.Cursor;
|
|
import google.registry.model.domain.DomainBase;
|
|
import google.registry.model.domain.Period;
|
|
import google.registry.model.ofy.Ofy;
|
|
import google.registry.model.registry.Registry;
|
|
import google.registry.model.reporting.DomainTransactionRecord;
|
|
import google.registry.model.reporting.DomainTransactionRecord.TransactionReportField;
|
|
import google.registry.model.reporting.HistoryEntry;
|
|
import google.registry.testing.FakeClock;
|
|
import google.registry.testing.FakeResponse;
|
|
import google.registry.testing.InjectRule;
|
|
import google.registry.testing.mapreduce.MapreduceTestCase;
|
|
import java.util.ArrayList;
|
|
import java.util.List;
|
|
import java.util.Optional;
|
|
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 ExpandRecurringBillingEventsAction}. */
|
|
@RunWith(JUnit4.class)
|
|
public class ExpandRecurringBillingEventsActionTest
|
|
extends MapreduceTestCase<ExpandRecurringBillingEventsAction> {
|
|
@Rule
|
|
public final InjectRule inject = new InjectRule();
|
|
|
|
private final DateTime beginningOfTest = DateTime.parse("2000-10-02T00:00:00Z");
|
|
private final FakeClock clock = new FakeClock(beginningOfTest);
|
|
|
|
DomainBase domain;
|
|
HistoryEntry historyEntry;
|
|
BillingEvent.Recurring recurring;
|
|
|
|
@Before
|
|
public void init() {
|
|
inject.setStaticField(Ofy.class, "clock", clock);
|
|
action = new ExpandRecurringBillingEventsAction();
|
|
action.mrRunner = makeDefaultRunner();
|
|
action.clock = clock;
|
|
action.cursorTimeParam = Optional.empty();
|
|
createTld("tld");
|
|
domain = persistActiveDomain("example.tld");
|
|
historyEntry = persistResource(new HistoryEntry.Builder().setParent(domain).build());
|
|
recurring = new BillingEvent.Recurring.Builder()
|
|
.setParent(historyEntry)
|
|
.setClientId(domain.getCreationClientId())
|
|
.setEventTime(DateTime.parse("2000-01-05T00:00:00Z"))
|
|
.setFlags(ImmutableSet.of(Flag.AUTO_RENEW))
|
|
.setId(2L)
|
|
.setReason(Reason.RENEW)
|
|
.setRecurrenceEndTime(END_OF_TIME)
|
|
.setTargetId(domain.getFullyQualifiedDomainName())
|
|
.build();
|
|
}
|
|
|
|
void saveCursor(final DateTime cursorTime) {
|
|
ofy().transact(() -> ofy().save().entity(Cursor.createGlobal(RECURRING_BILLING, cursorTime)));
|
|
}
|
|
|
|
void runMapreduce() throws Exception {
|
|
action.response = new FakeResponse();
|
|
action.run();
|
|
executeTasksUntilEmpty("mapreduce", clock);
|
|
ofy().clearSessionCache();
|
|
}
|
|
|
|
void assertCursorAt(DateTime expectedCursorTime) {
|
|
Cursor cursor = ofy().load().key(Cursor.createGlobalKey(RECURRING_BILLING)).now();
|
|
assertThat(cursor).isNotNull();
|
|
assertThat(cursor.getCursorTime()).isEqualTo(expectedCursorTime);
|
|
}
|
|
|
|
void assertHistoryEntryMatches(
|
|
DomainBase domain, HistoryEntry actual, String clientId, DateTime billingTime) {
|
|
assertThat(actual.getBySuperuser()).isFalse();
|
|
assertThat(actual.getClientId()).isEqualTo(clientId);
|
|
assertThat(actual.getParent()).isEqualTo(Key.create(domain));
|
|
assertThat(actual.getPeriod()).isEqualTo(Period.create(1, YEARS));
|
|
assertThat(actual.getReason())
|
|
.isEqualTo("Domain autorenewal by ExpandRecurringBillingEventsAction");
|
|
assertThat(actual.getRequestedByRegistrar()).isFalse();
|
|
assertThat(actual.getType()).isEqualTo(DOMAIN_AUTORENEW);
|
|
assertThat(actual.getDomainTransactionRecords())
|
|
.containsExactly(
|
|
DomainTransactionRecord.create(
|
|
"tld",
|
|
billingTime,
|
|
TransactionReportField.NET_RENEWS_1_YR,
|
|
1));
|
|
}
|
|
|
|
private OneTime.Builder defaultOneTimeBuilder() {
|
|
return new BillingEvent.OneTime.Builder()
|
|
.setBillingTime(DateTime.parse("2000-02-19T00:00:00Z"))
|
|
.setClientId("TheRegistrar")
|
|
.setCost(Money.of(USD, 11))
|
|
.setEventTime(DateTime.parse("2000-01-05T00:00:00Z"))
|
|
.setFlags(ImmutableSet.of(Flag.AUTO_RENEW, Flag.SYNTHETIC))
|
|
.setPeriodYears(1)
|
|
.setReason(Reason.RENEW)
|
|
.setSyntheticCreationTime(beginningOfTest)
|
|
.setCancellationMatchingBillingEvent(Key.create(recurring))
|
|
.setTargetId(domain.getFullyQualifiedDomainName());
|
|
}
|
|
|
|
@Test
|
|
public void testSuccess_expandSingleEvent() throws Exception {
|
|
persistResource(recurring);
|
|
action.cursorTimeParam = Optional.of(START_OF_TIME);
|
|
runMapreduce();
|
|
HistoryEntry persistedEntry = getOnlyHistoryEntryOfType(domain, DOMAIN_AUTORENEW);
|
|
assertHistoryEntryMatches(
|
|
domain, persistedEntry, "TheRegistrar", DateTime.parse("2000-02-19T00:00:00Z"));
|
|
BillingEvent.OneTime expected = defaultOneTimeBuilder()
|
|
.setParent(persistedEntry)
|
|
.build();
|
|
assertBillingEventsForResource(domain, expected, recurring);
|
|
assertCursorAt(beginningOfTest);
|
|
}
|
|
|
|
@Test
|
|
public void testSuccess_expandSingleEvent_deletedDomain() throws Exception {
|
|
DateTime deletionTime = DateTime.parse("2000-08-01T00:00:00Z");
|
|
DomainBase deletedDomain = persistDeletedDomain("deleted.tld", deletionTime);
|
|
historyEntry = persistResource(new HistoryEntry.Builder().setParent(deletedDomain).build());
|
|
recurring = persistResource(new BillingEvent.Recurring.Builder()
|
|
.setParent(historyEntry)
|
|
.setClientId(deletedDomain.getCreationClientId())
|
|
.setEventTime(DateTime.parse("2000-01-05T00:00:00Z"))
|
|
.setFlags(ImmutableSet.of(Flag.AUTO_RENEW))
|
|
.setId(2L)
|
|
.setReason(Reason.RENEW)
|
|
.setRecurrenceEndTime(deletionTime)
|
|
.setTargetId(deletedDomain.getFullyQualifiedDomainName())
|
|
.build());
|
|
action.cursorTimeParam = Optional.of(START_OF_TIME);
|
|
runMapreduce();
|
|
HistoryEntry persistedEntry = getOnlyHistoryEntryOfType(deletedDomain, DOMAIN_AUTORENEW);
|
|
assertHistoryEntryMatches(
|
|
deletedDomain, persistedEntry, "TheRegistrar", DateTime.parse("2000-02-19T00:00:00Z"));
|
|
BillingEvent.OneTime expected = defaultOneTimeBuilder()
|
|
.setParent(persistedEntry)
|
|
.setTargetId(deletedDomain.getFullyQualifiedDomainName())
|
|
.build();
|
|
assertBillingEventsForResource(deletedDomain, expected, recurring);
|
|
assertCursorAt(beginningOfTest);
|
|
}
|
|
|
|
@Test
|
|
public void testSuccess_expandSingleEvent_idempotentForDuplicateRuns() throws Exception {
|
|
persistResource(recurring);
|
|
action.cursorTimeParam = Optional.of(START_OF_TIME);
|
|
runMapreduce();
|
|
HistoryEntry persistedEntry = getOnlyHistoryEntryOfType(domain, DOMAIN_AUTORENEW);
|
|
assertHistoryEntryMatches(
|
|
domain, persistedEntry, "TheRegistrar", DateTime.parse("2000-02-19T00:00:00Z"));
|
|
BillingEvent.OneTime expected = defaultOneTimeBuilder().setParent(persistedEntry).build();
|
|
assertCursorAt(beginningOfTest);
|
|
DateTime beginningOfSecondRun = clock.nowUtc();
|
|
action.response = new FakeResponse();
|
|
runMapreduce();
|
|
assertCursorAt(beginningOfSecondRun);
|
|
assertBillingEventsForResource(domain, expected, recurring);
|
|
}
|
|
|
|
@Test
|
|
public void testSuccess_expandSingleEvent_idempotentForExistingOneTime() throws Exception {
|
|
persistResource(recurring);
|
|
BillingEvent.OneTime persisted = persistResource(defaultOneTimeBuilder()
|
|
.setParent(historyEntry)
|
|
.build());
|
|
action.cursorTimeParam = Optional.of(START_OF_TIME);
|
|
runMapreduce();
|
|
// No new history entries should be generated
|
|
assertThat(getHistoryEntriesOfType(domain, DOMAIN_AUTORENEW)).isEmpty();
|
|
assertCursorAt(beginningOfTest);
|
|
// No additional billing events should be generated
|
|
assertBillingEventsForResource(domain, persisted, recurring);
|
|
}
|
|
|
|
@Test
|
|
public void testSuccess_expandSingleEvent_notIdempotentForDifferentBillingTime()
|
|
throws Exception {
|
|
persistResource(recurring);
|
|
action.cursorTimeParam = Optional.of(START_OF_TIME);
|
|
runMapreduce();
|
|
HistoryEntry persistedEntry = getOnlyHistoryEntryOfType(domain, DOMAIN_AUTORENEW);
|
|
assertHistoryEntryMatches(
|
|
domain, persistedEntry, "TheRegistrar", DateTime.parse("2000-02-19T00:00:00Z"));
|
|
BillingEvent.OneTime expected = defaultOneTimeBuilder().setParent(persistedEntry).build();
|
|
// Persist an otherwise identical billing event that differs only in billing time.
|
|
BillingEvent.OneTime persisted = persistResource(expected.asBuilder()
|
|
.setBillingTime(DateTime.parse("1999-02-19T00:00:00Z"))
|
|
.setEventTime(DateTime.parse("1999-01-05T00:00:00Z"))
|
|
.build());
|
|
assertCursorAt(beginningOfTest);
|
|
assertBillingEventsForResource(domain, persisted, expected, recurring);
|
|
}
|
|
|
|
@Test
|
|
public void testSuccess_expandSingleEvent_notIdempotentForDifferentRecurring()
|
|
throws Exception {
|
|
persistResource(recurring);
|
|
BillingEvent.Recurring recurring2 = persistResource(recurring.asBuilder()
|
|
.setId(3L)
|
|
.build());
|
|
action.cursorTimeParam = Optional.of(START_OF_TIME);
|
|
runMapreduce();
|
|
List<HistoryEntry> persistedEntries =
|
|
getHistoryEntriesOfType(domain, DOMAIN_AUTORENEW);
|
|
for (HistoryEntry persistedEntry : persistedEntries) {
|
|
assertHistoryEntryMatches(
|
|
domain, persistedEntry, "TheRegistrar", DateTime.parse("2000-02-19T00:00:00Z"));
|
|
}
|
|
assertThat(persistedEntries).hasSize(2);
|
|
BillingEvent.OneTime expected = defaultOneTimeBuilder()
|
|
.setParent(persistedEntries.get(0))
|
|
.build();
|
|
// Persist an otherwise identical billing event that differs only in recurring event key.
|
|
BillingEvent.OneTime persisted = expected.asBuilder()
|
|
.setParent(persistedEntries.get(1))
|
|
.setCancellationMatchingBillingEvent(Key.create(recurring2))
|
|
.build();
|
|
assertCursorAt(beginningOfTest);
|
|
assertBillingEventsForResource(domain, persisted, expected, recurring, recurring2);
|
|
}
|
|
|
|
@Test
|
|
public void testSuccess_ignoreRecurringBeforeWindow() throws Exception {
|
|
recurring = persistResource(recurring.asBuilder()
|
|
.setEventTime(DateTime.parse("1997-01-05T00:00:00Z"))
|
|
.setRecurrenceEndTime(DateTime.parse("1999-10-05T00:00:00Z"))
|
|
.build());
|
|
action.cursorTimeParam = Optional.of(DateTime.parse("2000-01-01T00:00:00Z"));
|
|
runMapreduce();
|
|
// No new history entries should be generated
|
|
assertThat(getHistoryEntriesOfType(domain, DOMAIN_AUTORENEW)).isEmpty();
|
|
assertBillingEventsForResource(domain, recurring);
|
|
assertCursorAt(beginningOfTest);
|
|
}
|
|
|
|
@Test
|
|
public void testSuccess_ignoreRecurringAfterWindow() throws Exception {
|
|
recurring = persistResource(recurring.asBuilder()
|
|
.setEventTime(clock.nowUtc().plusYears(2))
|
|
.build());
|
|
action.cursorTimeParam = Optional.of(START_OF_TIME);
|
|
runMapreduce();
|
|
// No new history entries should be generated
|
|
assertThat(getHistoryEntriesOfType(domain, DOMAIN_AUTORENEW)).isEmpty();
|
|
assertBillingEventsForResource(domain, recurring);
|
|
}
|
|
|
|
@Test
|
|
public void testSuccess_expandSingleEvent_billingTimeAtCursorTime() throws Exception {
|
|
persistResource(recurring);
|
|
action.cursorTimeParam = Optional.of(DateTime.parse("2000-02-19T00:00:00Z"));
|
|
runMapreduce();
|
|
HistoryEntry persistedEntry = getOnlyHistoryEntryOfType(domain, DOMAIN_AUTORENEW);
|
|
assertHistoryEntryMatches(
|
|
domain, persistedEntry, "TheRegistrar", DateTime.parse("2000-02-19T00:00:00Z"));
|
|
BillingEvent.OneTime expected = defaultOneTimeBuilder().setParent(persistedEntry).build();
|
|
assertBillingEventsForResource(domain, expected, recurring);
|
|
assertCursorAt(beginningOfTest);
|
|
}
|
|
|
|
@Test
|
|
public void testSuccess_expandSingleEvent_cursorTimeBetweenEventAndBillingTime()
|
|
throws Exception {
|
|
persistResource(recurring);
|
|
action.cursorTimeParam = Optional.of(DateTime.parse("2000-01-12T00:00:00Z"));
|
|
runMapreduce();
|
|
HistoryEntry persistedEntry = getOnlyHistoryEntryOfType(domain, DOMAIN_AUTORENEW);
|
|
assertHistoryEntryMatches(
|
|
domain, persistedEntry, "TheRegistrar", DateTime.parse("2000-02-19T00:00:00Z"));
|
|
BillingEvent.OneTime expected = defaultOneTimeBuilder().setParent(persistedEntry).build();
|
|
assertBillingEventsForResource(domain, expected, recurring);
|
|
assertCursorAt(beginningOfTest);
|
|
}
|
|
|
|
@Test
|
|
public void testSuccess_expandSingleEvent_billingTimeAtExecutionTime() throws Exception {
|
|
DateTime testTime = DateTime.parse("2000-02-19T00:00:00Z").minusMillis(1);
|
|
persistResource(recurring);
|
|
action.cursorTimeParam = Optional.of(START_OF_TIME);
|
|
// Clock is advanced one milli in runMapreduce()
|
|
clock.setTo(testTime);
|
|
runMapreduce();
|
|
// No new history entries should be generated
|
|
assertThat(getHistoryEntriesOfType(domain, DOMAIN_AUTORENEW)).isEmpty();
|
|
// A candidate billing event is set to be billed exactly on 2/19/00 @ 00:00,
|
|
// but these should not be generated as the interval is closed on cursorTime, open on
|
|
// executeTime.
|
|
assertBillingEventsForResource(domain, recurring);
|
|
assertCursorAt(testTime);
|
|
}
|
|
|
|
@Test
|
|
public void testSuccess_expandSingleEvent_multipleYearCreate() throws Exception {
|
|
DateTime testTime = beginningOfTest.plusYears(2);
|
|
action.cursorTimeParam = Optional.of(recurring.getEventTime());
|
|
recurring =
|
|
persistResource(
|
|
recurring.asBuilder().setEventTime(recurring.getEventTime().plusYears(2)).build());
|
|
clock.setTo(testTime);
|
|
runMapreduce();
|
|
HistoryEntry persistedEntry = getOnlyHistoryEntryOfType(domain, DOMAIN_AUTORENEW);
|
|
assertHistoryEntryMatches(
|
|
domain, persistedEntry, "TheRegistrar", DateTime.parse("2002-02-19T00:00:00Z"));
|
|
BillingEvent.OneTime expected = defaultOneTimeBuilder()
|
|
.setBillingTime(DateTime.parse("2002-02-19T00:00:00Z"))
|
|
.setEventTime(DateTime.parse("2002-01-05T00:00:00Z"))
|
|
.setParent(persistedEntry)
|
|
.setSyntheticCreationTime(testTime)
|
|
.build();
|
|
assertBillingEventsForResource(domain, expected, recurring);
|
|
assertCursorAt(testTime);
|
|
}
|
|
|
|
@Test
|
|
public void testSuccess_expandSingleEvent_withCursor() throws Exception {
|
|
persistResource(recurring);
|
|
saveCursor(START_OF_TIME);
|
|
runMapreduce();
|
|
HistoryEntry persistedEntry = getOnlyHistoryEntryOfType(domain, DOMAIN_AUTORENEW);
|
|
assertHistoryEntryMatches(
|
|
domain, persistedEntry, "TheRegistrar", DateTime.parse("2000-02-19T00:00:00Z"));
|
|
BillingEvent.OneTime expected = defaultOneTimeBuilder().setParent(persistedEntry).build();
|
|
assertBillingEventsForResource(domain, expected, recurring);
|
|
assertCursorAt(beginningOfTest);
|
|
}
|
|
|
|
@Test
|
|
public void testSuccess_expandSingleEvent_withCursorPastExpected() throws Exception {
|
|
persistResource(recurring);
|
|
// Simulate a quick second run of the mapreduce (this should be a no-op).
|
|
saveCursor(clock.nowUtc().minusSeconds(1));
|
|
runMapreduce();
|
|
// No new history entries should be generated
|
|
assertThat(getHistoryEntriesOfType(domain, DOMAIN_AUTORENEW)).isEmpty();
|
|
assertBillingEventsForResource(domain, recurring);
|
|
assertCursorAt(beginningOfTest);
|
|
}
|
|
|
|
@Test
|
|
public void testSuccess_expandSingleEvent_recurrenceEndBeforeEvent() throws Exception {
|
|
// This can occur when a domain is transferred or deleted before a domain comes up for renewal.
|
|
recurring = persistResource(recurring.asBuilder()
|
|
.setRecurrenceEndTime(recurring.getEventTime().minusDays(5))
|
|
.build());
|
|
action.cursorTimeParam = Optional.of(START_OF_TIME);
|
|
runMapreduce();
|
|
// No new history entries should be generated
|
|
assertThat(getHistoryEntriesOfType(domain, DOMAIN_AUTORENEW)).isEmpty();
|
|
assertBillingEventsForResource(domain, recurring);
|
|
assertCursorAt(beginningOfTest);
|
|
}
|
|
|
|
@Test
|
|
public void testSuccess_expandSingleEvent_dryRun() throws Exception {
|
|
persistResource(recurring);
|
|
action.isDryRun = true;
|
|
saveCursor(START_OF_TIME); // Need a saved cursor to verify that it didn't move.
|
|
runMapreduce();
|
|
// No new history entries should be generated
|
|
assertThat(getHistoryEntriesOfType(domain, DOMAIN_AUTORENEW)).isEmpty();
|
|
assertBillingEventsForResource(domain, recurring);
|
|
assertCursorAt(START_OF_TIME); // Cursor doesn't move on a dry run.
|
|
}
|
|
|
|
@Test
|
|
public void testSuccess_expandSingleEvent_multipleYears() throws Exception {
|
|
DateTime testTime = clock.nowUtc().plusYears(5);
|
|
clock.setTo(testTime);
|
|
List<BillingEvent> expectedEvents = new ArrayList<>();
|
|
expectedEvents.add(persistResource(recurring));
|
|
action.cursorTimeParam = Optional.of(START_OF_TIME);
|
|
runMapreduce();
|
|
List<HistoryEntry> persistedEntries =
|
|
getHistoryEntriesOfType(domain, DOMAIN_AUTORENEW);
|
|
assertThat(persistedEntries).hasSize(6);
|
|
DateTime eventDate = DateTime.parse("2000-01-05T00:00:00Z");
|
|
DateTime billingDate = DateTime.parse("2000-02-19T00:00:00Z");
|
|
// Expecting events for '00, '01, '02, '03, '04, '05.
|
|
for (int year = 0; year < 6; year++) {
|
|
assertHistoryEntryMatches(
|
|
domain,
|
|
persistedEntries.get(year),
|
|
"TheRegistrar",
|
|
billingDate.plusYears(year));
|
|
expectedEvents.add(defaultOneTimeBuilder()
|
|
.setBillingTime(billingDate.plusYears(year))
|
|
.setEventTime(eventDate.plusYears(year))
|
|
.setParent(persistedEntries.get(year))
|
|
.setSyntheticCreationTime(testTime)
|
|
.build());
|
|
}
|
|
assertBillingEventsForResource(domain, Iterables.toArray(expectedEvents, BillingEvent.class));
|
|
assertCursorAt(testTime);
|
|
}
|
|
|
|
@Test
|
|
public void testSuccess_expandSingleEvent_multipleYears_cursorInBetweenYears() throws Exception {
|
|
DateTime testTime = clock.nowUtc().plusYears(5);
|
|
clock.setTo(testTime);
|
|
List<BillingEvent> expectedEvents = new ArrayList<>();
|
|
expectedEvents.add(persistResource(recurring));
|
|
saveCursor(DateTime.parse("2003-10-02T00:00:00Z"));
|
|
runMapreduce();
|
|
List<HistoryEntry> persistedEntries =
|
|
getHistoryEntriesOfType(domain, DOMAIN_AUTORENEW);
|
|
assertThat(persistedEntries).hasSize(2);
|
|
DateTime eventDate = DateTime.parse("2004-01-05T00:00:00Z");
|
|
DateTime billingDate = DateTime.parse("2004-02-19T00:00:00Z");
|
|
// Only expect the last two years' worth of billing events.
|
|
for (int year = 0; year < 2; year++) {
|
|
assertHistoryEntryMatches(
|
|
domain, persistedEntries.get(year), "TheRegistrar", billingDate.plusYears(year));
|
|
expectedEvents.add(defaultOneTimeBuilder()
|
|
.setBillingTime(billingDate.plusYears(year))
|
|
.setParent(persistedEntries.get(year))
|
|
.setEventTime(eventDate.plusYears(year))
|
|
.setSyntheticCreationTime(testTime)
|
|
.build());
|
|
}
|
|
assertBillingEventsForResource(
|
|
domain, Iterables.toArray(expectedEvents, BillingEvent.class));
|
|
assertCursorAt(testTime);
|
|
}
|
|
|
|
@Test
|
|
public void testSuccess_singleEvent_beforeRenewal() throws Exception {
|
|
DateTime testTime = DateTime.parse("2000-01-04T00:00:00Z");
|
|
clock.setTo(testTime);
|
|
persistResource(recurring);
|
|
action.cursorTimeParam = Optional.of(START_OF_TIME);
|
|
runMapreduce();
|
|
// No new history entries should be generated
|
|
assertThat(getHistoryEntriesOfType(domain, DOMAIN_AUTORENEW)).isEmpty();
|
|
assertBillingEventsForResource(domain, recurring);
|
|
assertCursorAt(testTime);
|
|
}
|
|
|
|
@Test
|
|
public void testSuccess_singleEvent_afterRecurrenceEnd() throws Exception {
|
|
DateTime testTime = beginningOfTest.plusYears(2);
|
|
clock.setTo(testTime);
|
|
recurring = persistResource(recurring.asBuilder()
|
|
// Set between event time and billing time (i.e. before the grace period expires) for 2000.
|
|
// We should still expect a billing event.
|
|
.setRecurrenceEndTime(DateTime.parse("2000-01-29T00:00:00Z"))
|
|
.build());
|
|
action.cursorTimeParam = Optional.of(START_OF_TIME);
|
|
runMapreduce();
|
|
HistoryEntry persistedEntry = getOnlyHistoryEntryOfType(domain, DOMAIN_AUTORENEW);
|
|
assertHistoryEntryMatches(
|
|
domain, persistedEntry, "TheRegistrar", DateTime.parse("2000-02-19T00:00:00Z"));
|
|
BillingEvent.OneTime expected = defaultOneTimeBuilder()
|
|
.setBillingTime(DateTime.parse("2000-02-19T00:00:00Z"))
|
|
.setParent(persistedEntry)
|
|
.setSyntheticCreationTime(testTime)
|
|
.build();
|
|
assertBillingEventsForResource(domain, recurring, expected);
|
|
assertCursorAt(testTime);
|
|
}
|
|
|
|
@Test
|
|
public void testSuccess_expandSingleEvent_billingTimeOnLeapYear() throws Exception {
|
|
recurring =
|
|
persistResource(
|
|
recurring.asBuilder().setEventTime(DateTime.parse("2000-01-15T00:00:00Z")).build());
|
|
action.cursorTimeParam = Optional.of(START_OF_TIME);
|
|
runMapreduce();
|
|
HistoryEntry persistedEntry = getOnlyHistoryEntryOfType(domain, DOMAIN_AUTORENEW);
|
|
assertHistoryEntryMatches(
|
|
domain, persistedEntry, "TheRegistrar", DateTime.parse("2000-02-29T00:00:00Z"));
|
|
BillingEvent.OneTime expected = defaultOneTimeBuilder()
|
|
.setBillingTime(DateTime.parse("2000-02-29T00:00:00Z"))
|
|
.setEventTime(DateTime.parse("2000-01-15T00:00:00Z"))
|
|
.setParent(persistedEntry)
|
|
.build();
|
|
assertBillingEventsForResource(domain, expected, recurring);
|
|
assertCursorAt(beginningOfTest);
|
|
}
|
|
|
|
@Test
|
|
public void testSuccess_expandSingleEvent_billingTimeNotOnLeapYear() throws Exception {
|
|
DateTime testTime = DateTime.parse("2001-12-01T00:00:00Z");
|
|
recurring =
|
|
persistResource(
|
|
recurring.asBuilder().setEventTime(DateTime.parse("2001-01-15T00:00:00Z")).build());
|
|
action.cursorTimeParam = Optional.of(START_OF_TIME);
|
|
clock.setTo(testTime);
|
|
runMapreduce();
|
|
HistoryEntry persistedEntry = getOnlyHistoryEntryOfType(domain, DOMAIN_AUTORENEW);
|
|
assertHistoryEntryMatches(
|
|
domain, persistedEntry, "TheRegistrar", DateTime.parse("2001-03-01T00:00:00Z"));
|
|
BillingEvent.OneTime expected = defaultOneTimeBuilder()
|
|
.setBillingTime(DateTime.parse("2001-03-01T00:00:00Z"))
|
|
.setEventTime(DateTime.parse("2001-01-15T00:00:00Z"))
|
|
.setParent(persistedEntry)
|
|
.setSyntheticCreationTime(testTime)
|
|
.build();
|
|
assertBillingEventsForResource(domain, expected, recurring);
|
|
assertCursorAt(testTime);
|
|
}
|
|
|
|
@Test
|
|
public void testSuccess_expandMultipleEvents() throws Exception {
|
|
persistResource(recurring);
|
|
BillingEvent.Recurring recurring2 = persistResource(recurring.asBuilder()
|
|
.setEventTime(recurring.getEventTime().plusMonths(3))
|
|
.setId(3L)
|
|
.build());
|
|
action.cursorTimeParam = Optional.of(START_OF_TIME);
|
|
runMapreduce();
|
|
List<HistoryEntry> persistedEntries = getHistoryEntriesOfType(domain, DOMAIN_AUTORENEW);
|
|
assertThat(persistedEntries).hasSize(2);
|
|
assertHistoryEntryMatches(
|
|
domain, persistedEntries.get(0), "TheRegistrar", DateTime.parse("2000-02-19T00:00:00Z"));
|
|
BillingEvent.OneTime expected = defaultOneTimeBuilder()
|
|
.setParent(persistedEntries.get(0))
|
|
.setCancellationMatchingBillingEvent(Key.create(recurring))
|
|
.build();
|
|
assertHistoryEntryMatches(
|
|
domain, persistedEntries.get(1), "TheRegistrar", DateTime.parse("2000-05-20T00:00:00Z"));
|
|
BillingEvent.OneTime expected2 = defaultOneTimeBuilder()
|
|
.setBillingTime(DateTime.parse("2000-05-20T00:00:00Z"))
|
|
.setEventTime(DateTime.parse("2000-04-05T00:00:00Z"))
|
|
.setParent(persistedEntries.get(1))
|
|
.setCancellationMatchingBillingEvent(Key.create(recurring2))
|
|
.build();
|
|
assertBillingEventsForResource(domain, expected, expected2, recurring, recurring2);
|
|
assertCursorAt(beginningOfTest);
|
|
}
|
|
|
|
@Test
|
|
public void testSuccess_premiumDomain() throws Exception {
|
|
persistResource(
|
|
Registry.get("tld")
|
|
.asBuilder()
|
|
.setPremiumList(persistPremiumList("tld2", "example,USD 100"))
|
|
.build());
|
|
persistResource(recurring);
|
|
action.cursorTimeParam = Optional.of(START_OF_TIME);
|
|
runMapreduce();
|
|
HistoryEntry persistedEntry = getOnlyHistoryEntryOfType(domain, DOMAIN_AUTORENEW);
|
|
assertHistoryEntryMatches(
|
|
domain, persistedEntry, "TheRegistrar", DateTime.parse("2000-02-19T00:00:00Z"));
|
|
BillingEvent.OneTime expected = defaultOneTimeBuilder()
|
|
.setParent(persistedEntry)
|
|
.setCost(Money.of(USD, 100))
|
|
.build();
|
|
assertBillingEventsForResource(domain, expected, recurring);
|
|
assertCursorAt(beginningOfTest);
|
|
}
|
|
|
|
@Test
|
|
public void testSuccess_varyingRenewPrices() throws Exception {
|
|
DateTime testTime = beginningOfTest.plusYears(1);
|
|
persistResource(
|
|
Registry.get("tld")
|
|
.asBuilder()
|
|
.setRenewBillingCostTransitions(
|
|
ImmutableSortedMap.of(
|
|
START_OF_TIME, Money.of(USD, 8),
|
|
DateTime.parse("2000-06-01T00:00:00Z"), Money.of(USD, 10)))
|
|
.build());
|
|
clock.setTo(testTime);
|
|
persistResource(recurring);
|
|
action.cursorTimeParam = Optional.of(START_OF_TIME);
|
|
runMapreduce();
|
|
List<HistoryEntry> persistedEntries =
|
|
getHistoryEntriesOfType(domain, DOMAIN_AUTORENEW);
|
|
assertThat(persistedEntries).hasSize(2);
|
|
DateTime eventDate = DateTime.parse("2000-01-05T00:00:00Z");
|
|
DateTime billingDate = DateTime.parse("2000-02-19T00:00:00Z");
|
|
assertHistoryEntryMatches(domain, persistedEntries.get(0), "TheRegistrar", billingDate);
|
|
BillingEvent.OneTime cheaper = defaultOneTimeBuilder()
|
|
.setBillingTime(billingDate)
|
|
.setEventTime(eventDate)
|
|
.setParent(persistedEntries.get(0))
|
|
.setCost(Money.of(USD, 8))
|
|
.setSyntheticCreationTime(testTime)
|
|
.build();
|
|
assertHistoryEntryMatches(
|
|
domain, persistedEntries.get(1), "TheRegistrar", billingDate.plusYears(1));
|
|
BillingEvent.OneTime expensive = cheaper.asBuilder()
|
|
.setCost(Money.of(USD, 10))
|
|
.setBillingTime(billingDate.plusYears(1))
|
|
.setEventTime(eventDate.plusYears(1))
|
|
.setParent(persistedEntries.get(1))
|
|
.build();
|
|
assertBillingEventsForResource(domain, recurring, cheaper, expensive);
|
|
assertCursorAt(testTime);
|
|
}
|
|
|
|
@Test
|
|
public void testFailure_cursorAfterExecutionTime() {
|
|
action.cursorTimeParam = Optional.of(clock.nowUtc().plusYears(1));
|
|
IllegalArgumentException thrown =
|
|
assertThrows(IllegalArgumentException.class, this::runMapreduce);
|
|
assertThat(thrown)
|
|
.hasMessageThat()
|
|
.contains("Cursor time must be earlier than execution time.");
|
|
}
|
|
|
|
@Test
|
|
public void testFailure_cursorAtExecutionTime() {
|
|
// The clock advances one milli on runMapreduce.
|
|
action.cursorTimeParam = Optional.of(clock.nowUtc().plusMillis(1));
|
|
IllegalArgumentException thrown =
|
|
assertThrows(IllegalArgumentException.class, this::runMapreduce);
|
|
assertThat(thrown)
|
|
.hasMessageThat()
|
|
.contains("Cursor time must be earlier than execution time.");
|
|
}
|
|
|
|
@Test
|
|
public void testFailure_mapperException_doesNotMoveCursor() throws Exception {
|
|
saveCursor(START_OF_TIME); // Need a saved cursor to verify that it didn't move.
|
|
// Set target to a TLD that doesn't exist.
|
|
recurring = persistResource(recurring.asBuilder().setTargetId("domain.junk").build());
|
|
runMapreduce();
|
|
// No new history entries should be generated
|
|
assertThat(getHistoryEntriesOfType(domain, DOMAIN_AUTORENEW)).isEmpty();
|
|
assertBillingEvents(recurring); // only the bogus one in Datastore
|
|
assertCursorAt(START_OF_TIME); // Cursor doesn't move on a failure.
|
|
}
|
|
}
|